package GUI;
import Applikationslogik.Alarm;
import Applikationslogik.AlarmImpl;
import Applikationslogik.Kalender;
import Applikationslogik.Kalendereintrag;
import Applikationslogik.Person;
import Applikationslogik.Kategorie;
import Applikationslogik.Termin;
import java.awt.BorderLayout;
import java.awt.EventQueue;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.text.ParseException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import java.awt.Dimension;
import javax.swing.JMenuBar;
import javax.swing.JMenu;
import javax.swing.JMenuItem;
import javax.swing.JLabel;
import java.awt.Font;
import javax.swing.JComboBox;
import javax.swing.JCheckBox;
import java.awt.event.ItemListener;
import java.awt.event.ItemEvent;
import javax.swing.JButton;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import javax.swing.JTextField;
import java.rmi.Naming;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;
import java.net.MalformedURLException;
import Applikationslogik.Verwaltung;
import Applikationslogik.Wiederholung;
import java.io.BufferedReader;
import java.io.FileReader;
import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Vector;
import javax.swing.ButtonGroup;
import javax.swing.DefaultComboBoxModel;
import javax.swing.JDialog;
import javax.swing.JOptionPane;


/**
 *
 * @author Rene
 */
public class GUI extends JFrame {
        private JPanel panel_Hintergrund;

        //Verwaltung
        Person eingeloggte_person;
        Verwaltung v = null;

        //Date
        private Date start_date_1;
        private Date end_date_1;

        //HashMaps
        private HashMap<String, Person> person;
        private HashMap<String, Kategorie> kategorie;
        private HashMap<String, Kalender> kalender;
        private HashMap<String, Kalendereintrag> kalendereintrag;
        private HashMap<String, Wiederholung> wiederholungen;
        private HashMap<String, Termin> termine;
        private HashMap<String, Termin> termin_wiederholungen;
        private HashMap<String, Kalendereintrag> teilnahmen;
        private HashMap<String, Alarm> alarm;

        //Vectoren
        private Vector <Person> unsere_personen;
        private Vector <Kategorie> unsere_kategorien;
        private Vector <Wiederholung> unsere_wiederholungen;
        private Vector <Termin> unsere_termine;
        private Vector <Termin> unsere_termin_wiederholung;
        private Vector <Kalendereintrag> unsere_kalendereintraege;

        //JDialog
        private JDialog dialog_Login ;

        //JLabel
        private JLabel label_anzahl_wiederholung;
        private JLabel label_uebersichtErstellen;
        private JLabel label_filter;
        private JLabel label_alarm_anlegen;
        private JLabel label_alarm_editieren;
        private JLabel label_alarm_loeschen;
        private JLabel label_alarm_bezeichnung;
        private JLabel label_alarm_uhrzeit;
        private JLabel label_comboBox_alarm;
        private JLabel label_ort;
        private JLabel teilnehmer_label[];
        private JLabel label_Einladung;
        private JLabel label_Kategorien;
        private JLabel label_KategorieName;
        private JLabel label_KategorieErstellen;
        private JLabel label_ArtDerWiederholung;
        private JLabel label_Beschreibung;
        private JLabel label_Enddatum;
        private JLabel label_enduhrzeit;
        private JLabel label_uebersicht;
        private JLabel label_Personen;
        private JLabel label_keine_berechtigung;
        private JLabel label_Kategorie;
        private JLabel label_KategorieBearbeiten;
        private JLabel label_BezeichnungNeu;
        private JLabel label_Benutzer;
        private JLabel label_Lesen;
        private JLabel label_Schreiben;
        private JLabel labels[];
        private JLabel label_KalenderWahl;
        private JLabel label_einladung_offen;
        private JLabel label_kalender_auswahl;

        //JButton
        private JButton button_logout;
        private JButton button_Erstellen;
        private JButton button_Abbrechen;
        private JButton button_startdatum;
        private JButton button_enddatum;
        private JButton button_alarm_kalender;
        private JButton button_teilnehmer_bestaetigen;
        private JButton button_Loeschen;
        private JButton button_teilnehmer_hinzufuegen;

        //JComboBox
        private JComboBox anzahl_wiederholung;
        private JComboBox comboBox_Monat;
        private JComboBox comboBox_Tag;
        private JComboBox comboBox_Eintrag;
        private JComboBox comboBox_alarm_std;
        private JComboBox comboBox_alarm_min;
        private JComboBox comboBox_alarm_bezeichnung;
        private JComboBox comboBox_Kategorien;
        private JComboBox comboBox_WiederholArt;
        private JComboBox comboBox_PersonenWahl;
        private JComboBox comboBox_Kalendername;
        private JComboBox comboBox_KalenderWahl;
        private JComboBox comboBox_BenutzerwahlKalender;
        private JComboBox comboBox_Kalenderwahl;
        private JComboBox comboBox_EintagWaehlen;
        private JComboBox offene_Einladung;
        private JComboBox einladung_kalender;
        private JComboBox comboBox_Kategoriewahl;
        private JComboBox comboBox_Tag2;
        private JComboBox comboBox_Monat2;

        //JCheckBox
        private JCheckBox chckbxTermin;
        private JCheckBox chckbxErinnern;
        private JCheckBox teilnehmer_checkbox[];
        private JCheckBox chckbxWiederholen;
        private JCheckBox chckbx_ErweiterteBerechtigungen;
        private JCheckBox chckbxKalendereintrag;
        private JCheckBox chckbxWiederholung;
        private JCheckBox chckbxTermine;
        private JCheckBox chckbxTerminWiederholung;
        private JCheckBox chckbx_LeseRecht;
        private JCheckBox chckbx_Schreibrecht;
        private JCheckBox chckbx_KeinRecht;
        private JCheckBox keinrecht[];
        private JCheckBox leserecht[];
        private JCheckBox schreibrecht[];

        //JPanel
        private JPanel panel_KalenderAnlegen;
        private JPanel panel_KalenderAendern;
        private JPanel panel_KalenderLoeschen;
        private JPanel panel_KalendereintragErstellen;
        private JPanel panel_KalendereintragAendern;
        private JPanel panel_KalendereintragLoeschen;
        private JPanel panel_KategorieAnlegen;
        private JPanel panel_KategorieAendern;
        private JPanel panel_KategorieLoeschen;
        private JPanel panel_teilnehmer_hinzufuegen;
        private JPanel panel_AlarmSetzen;
        private JPanel panel_Uebersicht;
        private JPanel panel_alarm_anlegen;
        private JPanel panel_alarm_editieren;
        private JPanel panel_alarm_loeschen;
        private JPanel panel_PersonErstellen;
        private JPanel panel_PersonAendern;
        private JPanel panel_PersonLoeschen;
        private JPanel panel_Einladung;

        //JTextField
        private JTextField textField_ort;
        private JTextField textField_alarm_bezeichnung;
        private JTextField textField_alarm_start;
        private JTextField textField_alarm_editieren;
        private JTextField textField_Beschreibung;
        private JTextField textField_enddatum;
        private JTextField textField_Nachname;
        private JTextField textField_Vorname;
        private JTextField textField_Raum;
        private JTextField textField_TelNr;
        private JTextField textField_Email;
        private JTextField textField_Kategoriename;
        private JTextField textField_Kalendername;
        private JTextField textField_startdatum;
        private JTextField textField_uebersicht;

        // Menueleiste mit Menuepunkten
        private JMenuBar menuBar;
        private JMenu menue_Person;
        private JMenu menue_Kalender;
        private JMenu menue_Kalendereintrag;
        private JMenu menue_Kategorie;
        private JMenu menue_Alarm;
        private JMenu menu_Uebersicht;
        private JMenu menue_Einladung;

        // Menueeintraege
        private JMenuItem menueeintrag_PersonErstellen;
        private JMenuItem menueeintrag_PersonAendern;
        private JMenuItem menueeintrag_PersonLoeschen;
        private JMenuItem menueeintrag_Einladung;
        private JMenuItem menueeintrag_KalenderErstellen;
        private JMenuItem menueeintrag_KalenderBearbeiten;
        private JMenuItem menueeintrag_KalenderLoeschen;  
        private JMenuItem menueeintrag_KalendereintragErstellen;
        private JMenuItem menueeintrag_KalendereintragBerbeiten;
        private JMenuItem menueeintrag_KalendereintragLoeschen;
        private JMenuItem menueeintrag_KategorieBearbeiten;
        private JMenuItem menueeintrag_KategorieErstellen;
        private JMenuItem menueeintrag_KategorieLoeschen;
        private JMenuItem menueeintrag_alarm_anlegen;
        private JMenuItem menueeintrag_alarm_editieren;
        private JMenuItem menueeintrag_alarm_loeschen;
        private JMenuItem menueeintrag_EinladungAnzeigen;
        private JMenuItem menueeintrag_UebersichtAnzeigen;

        //Sonstiges
        private Bestaetigung best_EintragLoeschen;
        private ButtonGroup gruppe[];

        /**
         *
         * @param args
         */
        public static void main(String[] args) {
                EventQueue.invokeLater(new Runnable() {
                        public void run() {
                                try {
                                        GUI frame = new GUI();
                                        frame.setVisible(true);
                                } catch (Exception e) {
                                        e.printStackTrace();
                                }
                        }
                });
        }




        /**
         * Gruppenkalender Hauptpanel
         */
        public GUI() {
               // Fenstereigenschaften setzen


                setTitle("GruppenKalender");
                setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                setBounds(100, 100, 800, 600);
                setResizable(false);

                Login dialog_Login = new Login();



                Vector <Person> unsere_personen = new Vector();


                // Wir lesen alle Personen aus und schreiben diese in einen neuen Vektor
                 try {
                     // Wir lesen alle Personen aus
                     v = getVerwaltung();
                     unsere_personen = v.getAllPerson();

                 } catch (RemoteException re) {

                 }

                //Hashmap für die ComboBox wird erstellt
                person = new HashMap<String,Person>();
                for (int i = 0; i < unsere_personen.size(); i++) {
                    try {
                        person.put(unsere_personen.elementAt(i).get_voller_name(), unsere_personen.elementAt(i));
                    } catch (RemoteException ex) {
                    }
                }

                //Hier kriegne wir das Person Objekt zurück mit welchem sich der Nutzer im Login angemeldet hat
               eingeloggte_person = dialog_Login.ermittleLoginUser(person);
        try {
            System.out.println(eingeloggte_person.get_voller_name());
        } catch (RemoteException ex) {
            Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
        }

                menueErzeugen();

                //Panels initialisieren
                initPanels();

                // Hintergrundspanel einrichten
                panel_Hintergrund = new JPanel();
                panel_Hintergrund.setPreferredSize(new Dimension(800, 600));
                panel_Hintergrund.setBounds(100, 0, 800, 600);
                panel_Hintergrund.setBorder(new EmptyBorder(5, 5, 5, 5));
                setContentPane(panel_Hintergrund);
                panel_Hintergrund.setLayout(new BorderLayout());

                /*
                panel_AlarmSetzen = new JPanel();
                panel_Hintergrund.add(panel_AlarmSetzen, BorderLayout.CENTER);
                panel_AlarmSetzen.setLayout(null);

                panel_Uebersicht = new JPanel();
                panel_Hintergrund.add(panel_Uebersicht);
                panel_Uebersicht.setLayout(null);

                */
                zeichnePanelUebersicht();
        }

        /**
         * Es wird ein Verwaltungsobjekt übergeben
         * @return v
         */
        public Verwaltung getVerwaltung(){


               try {
                   // Wir lesen die IP aus einer Textdatei
                  System.out.println("// Wir lesen die IP aus einer Textdatei");
                    FileReader fr = null;
                    try {
                        fr = new FileReader("config.txt");
                    } catch (FileNotFoundException ex) {
                        Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                    }
                    BufferedReader br = new BufferedReader(fr);

                    String zeile1 = null;
                    try {
                        zeile1 = br.readLine();
                    } catch (IOException ex) {
                        Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                    }
                    System.out.println("GUI verbindet zu: " + zeile1);
                    
                    v = (Verwaltung)Naming.lookup(zeile1);
                    System.out.println("V: Nächte Zeile sollte das v stehen");
                    System.out.println(v);
                    System.out.println("Verbunden, Verwaltungsobjekt erhalten");

                } catch (MalformedURLException murle) {
                    System.out.println(murle);
                } catch (RemoteException re) {
                    System.out.println(re);
                } catch (NotBoundException nbe) {
                    System.out.println(nbe);
                }
                return this.v;
            }

        private void menueErzeugen()
        {
                // Menueleiste zusammenbauen
                menuBar = new JMenuBar();
                setJMenuBar(menuBar);

                menu_Uebersicht = new JMenu("\u00DCbersicht");
                menuBar.add(menu_Uebersicht);

                menueeintrag_UebersichtAnzeigen = new JMenuItem("Anzeigen");
                menueeintrag_UebersichtAnzeigen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                                zeichnePanelUebersicht();
                        }
                });
                menu_Uebersicht.add(menueeintrag_UebersichtAnzeigen);

                menue_Person = new JMenu("Person");
                menuBar.add(menue_Person);

                menueeintrag_PersonErstellen = new JMenuItem("Person erstellen");
                menueeintrag_PersonErstellen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                                zeichnePanelPersonAnlegen();
                        }
                });
                menue_Person.add(menueeintrag_PersonErstellen);

                menueeintrag_PersonAendern = new JMenuItem("Person bearbeiten");
                menueeintrag_PersonAendern.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                                zeichnePanelPersonAendern();
                        }
                });
                menue_Person.add(menueeintrag_PersonAendern);

                menueeintrag_PersonLoeschen = new JMenuItem("Person l\u00F6schen");
                menueeintrag_PersonLoeschen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                                zeichnePanelPersonLoeschen();
                        }
                });
                menue_Person.add(menueeintrag_PersonLoeschen);

                menue_Kalender = new JMenu("Kalender");
                menuBar.add(menue_Kalender);

                menueeintrag_KalenderErstellen = new JMenuItem("Kalender erstellen");
                menueeintrag_KalenderErstellen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                                zeichnePanelKalenderAnlegen();
                        }
                });
                menue_Kalender.add(menueeintrag_KalenderErstellen);

                menueeintrag_KalenderBearbeiten = new JMenuItem("Kalender bearbeiten");
                menueeintrag_KalenderBearbeiten.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                                zeichnePanelKalenderBearbeiten();
                        }
                });
                menue_Kalender.add(menueeintrag_KalenderBearbeiten);

                menueeintrag_KalenderLoeschen = new JMenuItem("Kalender l\u00F6schen");
                menueeintrag_KalenderLoeschen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                                zeichnePanelKalenderLoeschen();
                        }
                });
                menue_Kalender.add(menueeintrag_KalenderLoeschen);

                menue_Kalendereintrag = new JMenu("Kalendereintrag");
                menuBar.add(menue_Kalendereintrag);

                menueeintrag_KalendereintragErstellen = new JMenuItem("Kalendereintrag erstellen");
                menueeintrag_KalendereintragErstellen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                                zeichnePanelKalendereintragErstellen();
                        }
                });
                menue_Kalendereintrag.add(menueeintrag_KalendereintragErstellen);

                menueeintrag_KalendereintragBerbeiten = new JMenuItem("Kalendereintrag bearbeiten");
                menueeintrag_KalendereintragBerbeiten.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                                zeichnePanelKalendereintragBearbeiten();
                        }
                });
                menue_Kalendereintrag.add(menueeintrag_KalendereintragBerbeiten);

                menueeintrag_KalendereintragLoeschen = new JMenuItem("Kalendereintrag l\u00F6schen");
                menueeintrag_KalendereintragLoeschen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                                zeichnePanelKalendereintragLoeschen();
                        }
                });
                menue_Kalendereintrag.add(menueeintrag_KalendereintragLoeschen);

                menue_Kategorie = new JMenu("Kategorie");
                menuBar.add(menue_Kategorie);

                menueeintrag_KategorieErstellen = new JMenuItem("Kategorie erstellen");
                menueeintrag_KategorieErstellen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                                zeichnePanelKategorieAnlegen();
                        }
                });
                menue_Kategorie.add(menueeintrag_KategorieErstellen);

                menueeintrag_KategorieBearbeiten = new JMenuItem("Kategorie bearbeiten");
                menueeintrag_KategorieBearbeiten.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                                zeichnePanelKategorieBearbeiten();
                        }
                });
                menue_Kategorie.add(menueeintrag_KategorieBearbeiten);

                menueeintrag_KategorieLoeschen = new JMenuItem("Kategorie l\u00F6schen");
                menueeintrag_KategorieLoeschen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                                zeichnePanelKategorieLoeschen();
                        }
                });
                menue_Kategorie.add(menueeintrag_KategorieLoeschen);

                menue_Alarm = new JMenu("Alarm");
                menuBar.add(menue_Alarm);

                menueeintrag_alarm_anlegen = new JMenuItem("Anlegen");
                menueeintrag_alarm_anlegen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                                zeichnePanelAlarmAnlegen();
                        }
                });
                menue_Alarm.add(menueeintrag_alarm_anlegen);

                menueeintrag_alarm_editieren = new JMenuItem("Editieren");
                menueeintrag_alarm_editieren.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                                zeichne_alarm_editieren();
                        }
                });
                menue_Alarm.add(menueeintrag_alarm_editieren);

                menueeintrag_alarm_loeschen = new JMenuItem("Löschen");
                menueeintrag_alarm_loeschen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                                zeichne_alarm_loeschen();
                        }
                });

                menue_Alarm.add(menueeintrag_alarm_loeschen);


                menueeintrag_UebersichtAnzeigen = new JMenuItem("Anzeigen");
                menueeintrag_KategorieLoeschen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                                zeichnePanelUebersicht();
                        }
                });
                menu_Uebersicht.add(menueeintrag_UebersichtAnzeigen);

                menue_Einladung = new JMenu("Offene Einladung");
                menuBar.add(menue_Einladung);

                menueeintrag_Einladung = new JMenuItem("Anzeigen");
                menueeintrag_Einladung.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                                zeichnePanel_Einladung();
                        }
                });
                menue_Einladung.add(menueeintrag_Einladung);
        }

        private void versteckePanels()
        {
                panel_KalenderAnlegen.setVisible(false);
                panel_KalenderAendern.setVisible(false);
                panel_KalenderLoeschen.setVisible(false);

                panel_KalendereintragErstellen.setVisible(false);
                panel_KalendereintragAendern.setVisible(false);
                panel_KalendereintragLoeschen.setVisible(false);

                panel_PersonErstellen.setVisible(false);
                panel_PersonAendern.setVisible(false);
                panel_PersonLoeschen.setVisible(false);

                panel_KategorieAnlegen.setVisible(false);
                panel_KategorieAendern.setVisible(false);
                panel_KategorieLoeschen.setVisible(false);

                panel_AlarmSetzen.setVisible(false);
                panel_Einladung.setVisible(false);
                panel_Uebersicht.setVisible(false);

                panel_alarm_anlegen.setVisible(false);
                panel_alarm_editieren.setVisible(false);
                panel_alarm_loeschen.setVisible(false);

                

                
        }

        private void zeichnePanel_Einladung()
        {
                versteckePanels();

                // Alle Kalender der derzeit eingeloggten Person werden ausgelesen
                Vector <Kalender> unsere_kalender = new Vector();
                
                // Alle Einladungen der eingeloggten Person werden ausgelesen
                Vector <Kalendereintrag> unsere_nicht_vergebenen_eintraege = new Vector();

                try {
                     // Wir lesen alle Personen aus
                     v = getVerwaltung();
                     unsere_kalender = v.getKalender_byPerson(eingeloggte_person);
                     unsere_nicht_vergebenen_eintraege = v.find_all_einladungen_by_person(eingeloggte_person);

                 } catch (RemoteException re) {

                 }

                //Hashmap für die ComboBox Kalender wird erstellt
                kalender = new HashMap<String, Kalender>();
                for (int i = 0; i < unsere_kalender.size(); i++) {
                    try {
                        kalender.put(unsere_kalender.elementAt(i).get_bezeichnung(), unsere_kalender.elementAt(i));
                    } catch (RemoteException ex) {
                    }
                }

                //Hashmap für die ComboBox der noch offenen Teilnahmen wird erstellt
                teilnahmen = new HashMap<String, Kalendereintrag>();
                for (int i = 0; i < unsere_nicht_vergebenen_eintraege.size(); i++) {
                    try {
                        teilnahmen.put("<html><u>" +
                               unsere_nicht_vergebenen_eintraege.elementAt(i).get_beschreibung() +
                               "</u><br>" + unsere_nicht_vergebenen_eintraege.elementAt(i).get_start() + " bis<br>" +
                               unsere_nicht_vergebenen_eintraege.elementAt(i).get_ende() + "</html>"
                               , unsere_nicht_vergebenen_eintraege.elementAt(i));



                    } catch (RemoteException ex) {
                    }
                }

                System.out.println("Einladung");
                panel_Hintergrund.removeAll();
                panel_Einladung = new JPanel();
                panel_Hintergrund.add(panel_Einladung, BorderLayout.CENTER);
                panel_Einladung.setLayout(null);

                label_Einladung = new JLabel("Offene Einladungen");
                label_Einladung.setFont(new Font("Tahoma", Font.PLAIN, 15));
                label_Einladung.setBounds(50, 30, 220, 30);
                panel_Einladung.add(label_Einladung);

                label_einladung_offen = new JLabel("<html>Offene Einladungen<br> auswählen</html>");
                label_einladung_offen.setBounds(50, 75, 220, 30);
                panel_Einladung.add(label_einladung_offen);

                offene_Einladung = new JComboBox(new DefaultComboBoxModel());
                offene_Einladung.setBounds(210, 80, 450, 60);
                panel_Einladung.add(offene_Einladung);

                // Füllen der ComboBox mit den offenen Kalendereinträgen (können auch Termine, Wiederholungen sein) der derzeit eingeloggten Person
                for (String key : teilnahmen.keySet()) {
                    offene_Einladung.addItem(key);
                }

                label_kalender_auswahl = new JLabel("Kalender auswählen");
                label_kalender_auswahl.setBounds(50, 145, 110, 30);
                panel_Einladung.add(label_kalender_auswahl);


                einladung_kalender = new JComboBox(new DefaultComboBoxModel());
                einladung_kalender.setBounds(210, 150, 450, 20);
                panel_Einladung.add(einladung_kalender);

                // Füllen der ComboBox mit den Kalendereinträgen der derzeit eingeloggten Person
                for (String key : kalender.keySet()) {
                    einladung_kalender.addItem(key);
                }



                button_Abbrechen = new JButton("Abbrechen");
                button_Abbrechen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                        }
                });
                button_Abbrechen.setBounds(210, 490, 120, 20);
                panel_Einladung.add(button_Abbrechen);

                button_Erstellen = new JButton("zuweisen");
                button_Erstellen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent arg0) {
                try {
                    // Wir weisen zu
                    
                    v.zuweisung_Kalender_Teilnahme(teilnahmen.get(offene_Einladung.getSelectedItem()), kalender.get(einladung_kalender.getSelectedItem()), eingeloggte_person);
                    JOptionPane.showMessageDialog(panel_Einladung, "Einladung wurde ihrem Kalender zugewiesen.");
                    zeichnePanelUebersicht();
                    
                } catch (RemoteException ex) {
                    Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                }

                        }
                });
                button_Erstellen.setBounds(50, 490, 90, 20);
                panel_Einladung.add(button_Erstellen);


                panel_Einladung.setVisible(true);
        }


        // Methoden, die die einzelnen Panels anzeigen lassen
        private void zeichnePanelKalenderAnlegen()
        {
                versteckePanels();
                unsere_personen = new Vector();

                try {
                     // Wir lesen alle Personen aus
                     v = getVerwaltung();
                     unsere_personen = v.getAllPerson_ohne_uebergebene_person(eingeloggte_person);

                 } catch (RemoteException re) {

                 }


                panel_Hintergrund.removeAll();
                panel_KalenderAnlegen = new JPanel();
                panel_Hintergrund.add(panel_KalenderAnlegen, BorderLayout.CENTER);
                panel_KalenderAnlegen.setLayout(null);

                JLabel label_KalenderAnlegen = new JLabel("Kalender erstellen");
                label_KalenderAnlegen.setFont(new Font("Tahoma", Font.PLAIN, 15));
                label_KalenderAnlegen.setBounds(50, 30, 220, 30);
                panel_KalenderAnlegen.add(label_KalenderAnlegen);

                JLabel label_Bezeichnung = new JLabel("Bezeichnung");
                label_Bezeichnung.setBounds(50, 80, 130, 30);
                panel_KalenderAnlegen.add(label_Bezeichnung);

                textField_Kalendername = new JTextField();
                textField_Kalendername.setBounds(210, 80, 250, 20);
                panel_KalenderAnlegen.add(textField_Kalendername);

                //Berechtigungen

                label_Benutzer = new JLabel("Benutzer");
                label_Benutzer.setBounds(50, 120, 60, 20);
                label_Benutzer.setVisible(true);
                panel_KalenderAnlegen.add(label_Benutzer);

                label_keine_berechtigung = new JLabel("Keine Rechte");
                label_keine_berechtigung.setBounds(210, 150, 100, 20);
                label_keine_berechtigung.setVisible(true);
                panel_KalenderAnlegen.add(label_keine_berechtigung);

                label_Lesen = new JLabel("Leserechte");
                label_Lesen.setBounds(340, 150, 100, 20);
                label_Lesen.setVisible(true);
                panel_KalenderAnlegen.add(label_Lesen);

                label_Schreiben = new JLabel("Lese- und Schreibrecht");
                label_Schreiben.setBounds(470, 150, 200, 20);
                label_Schreiben.setVisible(true);
                panel_KalenderAnlegen.add(label_Schreiben);


                // Hier fängt unser FOR Panel an

                int y_position = 180;

                int attempts = unsere_personen.size();
                labels = new JLabel[attempts];
                keinrecht = new JCheckBox[attempts];
                leserecht = new JCheckBox[attempts];
                schreibrecht = new JCheckBox[attempts];
                gruppe = new ButtonGroup[attempts];


                for(int i=0; i< unsere_personen.size(); i++ )
                {
                    try {
                        
                        labels[i] = new JLabel(unsere_personen.elementAt(i).get_voller_name());
                        labels[i].setBounds(50, y_position, 180, 20);
                        labels[i].setVisible(true);
                        panel_KalenderAnlegen.add(labels[i]);

                        keinrecht[i] = new JCheckBox("", true);
                        keinrecht[i].setBounds(210, y_position, 20, 20);
                        keinrecht[i].setVisible(true);
                        panel_KalenderAnlegen.add(keinrecht[i]);

                        leserecht[i] = new JCheckBox("");
                        leserecht[i].setBounds(350, y_position, 20, 20);
                        leserecht[i].setVisible(true);
                        panel_KalenderAnlegen.add(leserecht[i]);

                        schreibrecht[i] = new JCheckBox("");
                        schreibrecht[i].setBounds(490, y_position, 20, 20);
                        schreibrecht[i].setVisible(true);
                        panel_KalenderAnlegen.add(schreibrecht[i]);

                        gruppe[i] = new ButtonGroup();
                        gruppe[i].add(keinrecht[i]);
                        gruppe[i].add(leserecht[i]);
                        gruppe[i].add(schreibrecht[i]);

                        y_position = y_position + 30;

                    } catch (RemoteException ex) {
                        Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                    }

                }

                /// HIER ENDE FOR PANEL

                button_Erstellen = new JButton("Erstellen");
                button_Erstellen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent arg0) {

                                 if(textField_Kalendername.getText().equals(""))
                                 JOptionPane.showMessageDialog(panel_PersonErstellen, "Bitte Bezeichnung ausfüllen!");
                                 else {

                                     // Hier lesen wir aus, wie oft die FOR Schleife durchlaufen muss
                                     int anzahl_personen = 0;
                                            try {
                                                anzahl_personen = v.getAllPerson_ohne_uebergebene_person(eingeloggte_person).size();
                                            } catch (RemoteException ex) {
                                                Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                            }

                                   // Listen für die Verwaltung werden erstellt
                                     List<Integer> personenliste_lesen = new ArrayList<Integer>();
                                     List<Integer> personenliste_schreiben = new ArrayList<Integer>();

                                   for(int i=0; i< anzahl_personen; i++ )
                                   {
                                       int person_id = 0;
                                            try {
                                                //Wir lesen die Person_ID aus
                                                Person x = v.getAllPerson_ohne_uebergebene_person(eingeloggte_person).elementAt(i);
                                                person_id = x.get_person_id();
                                            } catch (RemoteException ex) {
                                                Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                            }

                                       if(leserecht[i].isSelected()){
                                           personenliste_lesen.add(person_id);
                                       }

                                       else if(schreibrecht[i].isSelected()) {
                                           personenliste_schreiben.add(person_id);
                                           personenliste_lesen.add(person_id);
                                       }
                                       else {
                                           System.out.println("Person " + person_id + " bekommt keine Rechte");
                                       }


                                   }
                                        try {
                                            // Der Besitzer erhält nun auch noch Lese + Schreibrechte
                                            personenliste_schreiben.add(eingeloggte_person.get_person_id());
                                            personenliste_lesen.add(eingeloggte_person.get_person_id());
                                        } catch (RemoteException ex) {
                                            Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                        }
                                        

                                        try {
                                            // Jetzt erstellen wir den Kalender in der Verwaltung
                                            v.createKalender(1, textField_Kalendername.getText(), eingeloggte_person.get_person_id(), personenliste_lesen, personenliste_schreiben);
                                            JOptionPane.showMessageDialog(panel_KalenderAnlegen, "Kalender angelegt.");
                                        zeichnePanelUebersicht();
                                        } catch (RemoteException ex) {
                                            Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                        }

                                 }

                        }
                });
                button_Erstellen.setBounds(50, 490, 90, 20);
                panel_KalenderAnlegen.add(button_Erstellen);

                button_Abbrechen = new JButton("Abbrechen");
                button_Abbrechen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                            zeichnePanelUebersicht();
                        }
                });
                button_Abbrechen.setBounds(210, 490, 120, 20);
                panel_KalenderAnlegen.add(button_Abbrechen);

                panel_KalenderAnlegen.setVisible(true);
        }

        private void zeichnePanelKalenderBearbeiten()
        {
                versteckePanels();
                 Vector <Kalender> unsere_kalender = new Vector();

                try {
                     // Wir lesen alle Personen aus
                     v = getVerwaltung();
                     unsere_kalender = v.getKalender_byPerson(eingeloggte_person);

                 } catch (RemoteException re) {

                 }

                unsere_personen = new Vector();

                try {
                     // Wir lesen alle Personen aus
                     v = getVerwaltung();
                     unsere_personen = v.getAllPerson_ohne_uebergebene_person(eingeloggte_person);

                 } catch (RemoteException re) {

                 }

                //Hashmap für die ComboBox wird erstellt
                kalender = new HashMap<String, Kalender>();
                for (int i = 0; i < unsere_kalender.size(); i++) {
                    try {
                        kalender.put(unsere_kalender.elementAt(i).get_bezeichnung(), unsere_kalender.elementAt(i));
                    } catch (RemoteException ex) {
                    }
                }

                panel_Hintergrund.removeAll();
                panel_KalenderAendern = new JPanel();
                panel_Hintergrund.add(panel_KalenderAendern, BorderLayout.CENTER);
                panel_KalenderAendern.setLayout(null);

                JLabel label_KalenderAnlegen = new JLabel("Kalender bearbeiten");
                label_KalenderAnlegen.setFont(new Font("Tahoma", Font.PLAIN, 15));
                label_KalenderAnlegen.setBounds(50, 30, 220, 30);
                panel_KalenderAendern.add(label_KalenderAnlegen);

                label_KalenderWahl = new JLabel("Kalender wählen");
                label_KalenderWahl.setBounds(50, 80, 130, 30);
                panel_KalenderAendern.add(label_KalenderWahl);

                comboBox_KalenderWahl = new JComboBox(new DefaultComboBoxModel());
                comboBox_KalenderWahl.setBounds(210, 80, 200, 20);
                panel_KalenderAendern.add(comboBox_KalenderWahl);

                 for (String key : kalender.keySet()) {
                    comboBox_KalenderWahl.addItem(key);
                }

                comboBox_KalenderWahl.addActionListener(new ActionListener() {
                    public void actionPerformed(ActionEvent e) {
                        // Auslesen des ersten Eintrages für die JTextFielder
                    try {
                        textField_Kalendername.setText(kalender.get(comboBox_KalenderWahl.getSelectedItem()).get_bezeichnung());

                        //Momentane selektierte Kalender_ID auslesen, für später wichtig um Rechte auszulesen
                        int kalender_id = kalender.get(comboBox_KalenderWahl.getSelectedItem()).get_kalender_id();

                        System.out.println("Selektierter Kalender: " + kalender_id );

                        //Es werden alle CheckBoxen wieder auf Default gesetzt bevor die Berechtigungen ausgelesen werden.
                        for(int i=0; i < unsere_personen.size(); i++)
                        {
                            keinrecht[i].setSelected(true);
                        }

                        // Nun werden die Berechtigungen gecheckt und dementsprechend angekreuzt
                        for(int i=0; i < unsere_personen.size(); i++)
                        {
                            System.out.println("Ich bin in der Schleife und es hat getroffen.");
                            System.out.println(labels[i].getText());
                            if(unsere_personen.get(i).get_voller_name().equals(labels[i].getText()))
                            {
                                System.out.println("Ich bin in der Schleife und es hat getroffen111.");
                                List<Integer> personenliste_lesen = new ArrayList<Integer>();
                                List<Integer> personenliste_schreiben = new ArrayList<Integer>();
                                // Person_ID an dieser Steller auslesen und dann überprüfen ob Berechtigungen vorliegen
                                int person_id_x = 0;
                                person_id_x = unsere_personen.get(i).get_person_id();
                                personenliste_lesen = kalender.get(comboBox_KalenderWahl.getSelectedItem()).get_berechtigung_lesen();
                                personenliste_schreiben = kalender.get(comboBox_KalenderWahl.getSelectedItem()).get_berechtigung_schreiben();

                                    for(int f=0; f < personenliste_lesen.size() ;f++)
                                    {
                                        if(personenliste_lesen.get(f) == person_id_x)
                                            leserecht[i].setSelected(true);
                                       
                                        else
                                            System.out.println("Person " + person_id_x + " hat keine LeseRechte.");
                                    }

                                    for(int f=0; f < personenliste_schreiben.size() ;f++)
                                    {
                                        if(personenliste_schreiben.get(f) == person_id_x)
                                            schreibrecht[i].setSelected(true);

                                        else
                                            System.out.println("Person " + person_id_x + " hat keine SchreibRechte.");
                                    }

                                leserecht[i].updateUI();
                                schreibrecht[i].updateUI();

                            }
                            
                        }



                    } catch (RemoteException ex) {
                        Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                    }
                    textField_Kalendername.updateUI();
                }
                });

                JLabel label_Bezeichnung = new JLabel("Bezeichnung");
                label_Bezeichnung.setBounds(50, 110, 130, 30);
                panel_KalenderAendern.add(label_Bezeichnung);

                textField_Kalendername = new JTextField();
                textField_Kalendername.setBounds(210, 110, 250, 20);
                panel_KalenderAendern.add(textField_Kalendername);

                //Berechtigungen

                label_Benutzer = new JLabel("Benutzer");
                label_Benutzer.setBounds(50, 150, 60, 20);
                label_Benutzer.setVisible(true);
                panel_KalenderAendern.add(label_Benutzer);

                label_keine_berechtigung = new JLabel("Keine Rechte");
                label_keine_berechtigung.setBounds(210, 150, 100, 20);
                label_keine_berechtigung.setVisible(true);
                panel_KalenderAendern.add(label_keine_berechtigung);

                label_Lesen = new JLabel("Leserechte");
                label_Lesen.setBounds(340, 150, 100, 20);
                label_Lesen.setVisible(true);
                panel_KalenderAendern.add(label_Lesen);

                label_Schreiben = new JLabel("Lese- und Schreibrecht");
                label_Schreiben.setBounds(470, 150, 200, 20);
                label_Schreiben.setVisible(true);
                panel_KalenderAendern.add(label_Schreiben);


                // Hier fängt unser FOR Panel an

                int y_position = 180;

                int attempts = unsere_personen.size();
                labels = new JLabel[attempts];
                keinrecht = new JCheckBox[attempts];
                leserecht = new JCheckBox[attempts];
                schreibrecht = new JCheckBox[attempts];
                gruppe = new ButtonGroup[attempts];


                for(int i=0; i< unsere_personen.size(); i++ )
                {
                    try {

                        labels[i] = new JLabel(unsere_personen.elementAt(i).get_voller_name());
                        labels[i].setBounds(50, y_position, 180, 20);
                        labels[i].setVisible(true);
                        panel_KalenderAendern.add(labels[i]);

                        keinrecht[i] = new JCheckBox("", true);
                        keinrecht[i].setBounds(210, y_position, 20, 20);
                        keinrecht[i].setVisible(true);
                        panel_KalenderAendern.add(keinrecht[i]);

                        leserecht[i] = new JCheckBox("");
                        leserecht[i].setBounds(350, y_position, 20, 20);
                        leserecht[i].setVisible(true);
                        panel_KalenderAendern.add(leserecht[i]);

                        schreibrecht[i] = new JCheckBox("");
                        schreibrecht[i].setBounds(490, y_position, 20, 20);
                        schreibrecht[i].setVisible(true);
                        panel_KalenderAendern.add(schreibrecht[i]);

                        gruppe[i] = new ButtonGroup();
                        gruppe[i].add(keinrecht[i]);
                        gruppe[i].add(leserecht[i]);
                        gruppe[i].add(schreibrecht[i]);

                        y_position = y_position + 30;

                    } catch (RemoteException ex) {
                        Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                    }

                }

                button_Erstellen = new JButton("\u00C4ndern");
                button_Erstellen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent arg0) {

                                 if(textField_Kalendername.getText().equals(""))
                                 JOptionPane.showMessageDialog(textField_Kalendername, "Bitte Bezeichnung ausfüllen!");
                                 else {

                                     // Hier lesen wir aus, wie oft die FOR Schleife durchlaufen muss
                                     int anzahl_personen = 0;
                                            try {
                                                anzahl_personen = v.getAllPerson_ohne_uebergebene_person(eingeloggte_person).size();
                                            } catch (RemoteException ex) {
                                                Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                            }

                                   // Listen für die Verwaltung werden erstellt
                                     List<Integer> personenliste_lesen = new ArrayList<Integer>();
                                     List<Integer> personenliste_schreiben = new ArrayList<Integer>();

                                   for(int i=0; i< anzahl_personen; i++ )
                                   {
                                       int person_id = 0;
                                            try {
                                                //Wir lesen die Person_ID aus
                                                Person x = v.getAllPerson_ohne_uebergebene_person(eingeloggte_person).elementAt(i);
                                                person_id = x.get_person_id();
                                            } catch (RemoteException ex) {
                                                Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                            }

                                       if(leserecht[i].isSelected()){
                                           personenliste_lesen.add(person_id);
                                       }

                                       else if(schreibrecht[i].isSelected()) {
                                           personenliste_schreiben.add(person_id);
                                           personenliste_lesen.add(person_id);
                                       }
                                       else {
                                           System.out.println("Person " + person_id + " bekommt keine Rechte");
                                       }


                                   }
                                        try {
                                            // Der Besitzer erhält nun auch noch Lese + Schreibrechte
                                            personenliste_schreiben.add(eingeloggte_person.get_person_id());
                                            personenliste_lesen.add(eingeloggte_person.get_person_id());
                                        } catch (RemoteException ex) {
                                            Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                        }


                                        try {
                                            // Hier überschreiben wir das ausgewählte Kalenderobjekt mit den neuen eingetragenen Daten
                                            kalender.get(comboBox_KalenderWahl.getSelectedItem()).set_bezeichnung(textField_Kalendername.getText());
                                            kalender.get(comboBox_KalenderWahl.getSelectedItem()).set_berechtigung_lesen(personenliste_lesen);
                                            kalender.get(comboBox_KalenderWahl.getSelectedItem()).set_berechtigung_schreiben(personenliste_schreiben);
                                            // Jetzt erstellen wir den Kalender in der Verwaltung
                                            v.updateKalender(kalender.get(comboBox_KalenderWahl.getSelectedItem()));
                                            JOptionPane.showMessageDialog(panel_KalenderAendern, "Kalender editiert.");
                                        zeichnePanelUebersicht();
                                        } catch (RemoteException ex) {
                                            Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                        }

                                 }

                        }
                });
                button_Erstellen.setBounds(50, 490, 90, 20);
                panel_KalenderAendern.add(button_Erstellen);

                button_Abbrechen = new JButton("Abbrechen");
                button_Abbrechen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                            zeichnePanelUebersicht();
                        }

                });
                button_Abbrechen.setBounds(210, 490, 120, 20);
                panel_KalenderAendern.add(button_Abbrechen);

                panel_KalenderAendern.setVisible(true);

                // Auslesen des ersten Eintrages für die JTextFielder
                 try {
                        textField_Kalendername.setText(kalender.get(comboBox_KalenderWahl.getSelectedItem()).get_bezeichnung());

                    } catch (RemoteException ex) {
                        Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                    }
                    textField_Kalendername.updateUI();
                    
               {
                        // Auslesen des ersten Eintrages für die JTextFielder
                    try {
                        textField_Kalendername.setText(kalender.get(comboBox_KalenderWahl.getSelectedItem()).get_bezeichnung());

                        //Momentane selektierte Kalender_ID auslesen, für später wichtig um Rechte auszulesen
                        int kalender_id = kalender.get(comboBox_KalenderWahl.getSelectedItem()).get_kalender_id();

                        System.out.println("Selektierter Kalender: " + kalender_id );

                        //Es werden alle CheckBoxen wieder auf Default gesetzt bevor die Berechtigungen ausgelesen werden.
                        for(int i=0; i < unsere_personen.size(); i++)
                        {
                            keinrecht[i].setSelected(true);
                        }

                        // Nun werden die Berechtigungen gecheckt und dementsprechend angekreuzt
                        for(int i=0; i < unsere_personen.size(); i++)
                        {
                            System.out.println("Ich bin in der Schleife und es hat getroffen.");
                            System.out.println(labels[i].getText());
                            if(unsere_personen.get(i).get_voller_name().equals(labels[i].getText()))
                            {
                                System.out.println("Ich bin in der Schleife und es hat getroffen111.");
                                List<Integer> personenliste_lesen = new ArrayList<Integer>();
                                List<Integer> personenliste_schreiben = new ArrayList<Integer>();
                                // Person_ID an dieser Steller auslesen und dann überprüfen ob Berechtigungen vorliegen
                                int person_id_x = 0;
                                person_id_x = unsere_personen.get(i).get_person_id();
                                personenliste_lesen = kalender.get(comboBox_KalenderWahl.getSelectedItem()).get_berechtigung_lesen();
                                personenliste_schreiben = kalender.get(comboBox_KalenderWahl.getSelectedItem()).get_berechtigung_schreiben();

                                    for(int f=0; f < personenliste_lesen.size() ;f++)
                                    {
                                        if(personenliste_lesen.get(f) == person_id_x)
                                            leserecht[i].setSelected(true);

                                        else
                                            System.out.println("Person " + person_id_x + " hat keine LeseRechte.");
                                    }

                                    for(int f=0; f < personenliste_schreiben.size() ;f++)
                                    {
                                        if(personenliste_schreiben.get(f) == person_id_x)
                                            schreibrecht[i].setSelected(true);

                                        else
                                            System.out.println("Person " + person_id_x + " hat keine SchreibRechte.");
                                    }

                                leserecht[i].updateUI();
                                schreibrecht[i].updateUI();

                            }

                        }



                    } catch (RemoteException ex) {
                        Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                    }
                    textField_Kalendername.updateUI();
                }
        }

        private void zeichnePanelKalenderLoeschen()
        {
                versteckePanels();

                Vector <Kalender> unsere_kalender = new Vector();

                try {
                     // Wir lesen alle Personen aus
                     v = getVerwaltung();
                     unsere_kalender = v.getKalender_byPerson(eingeloggte_person);

                 } catch (RemoteException re) {

                 }

                //Hashmap für die ComboBox wird erstellt
                kalender = new HashMap<String, Kalender>();
                for (int i = 0; i < unsere_kalender.size(); i++) {
                    try {
                        kalender.put(unsere_kalender.elementAt(i).get_bezeichnung(), unsere_kalender.elementAt(i));
                    } catch (RemoteException ex) {
                    }
                }


                panel_Hintergrund.removeAll();
                panel_KalenderLoeschen = new JPanel();
                panel_Hintergrund.add(panel_KalenderLoeschen, BorderLayout.CENTER);
                panel_KalenderLoeschen.setLayout(null);

                JLabel label_KalenderAendern = new JLabel("Kalender l\u00F6schen");
                label_KalenderAendern.setFont(new Font("Tahoma", Font.PLAIN, 15));
                label_KalenderAendern.setBounds(50, 30, 220, 30);
                panel_KalenderLoeschen.add(label_KalenderAendern);

                JLabel label_Kalenderwahl = new JLabel("Kalender w\u00E4hlen");
                label_Kalenderwahl.setBounds(50, 80, 130, 30);
                panel_KalenderLoeschen.add(label_Kalenderwahl);

                comboBox_Kalendername = new JComboBox();
                comboBox_Kalendername.setBounds(210, 80, 250, 20);
                panel_KalenderLoeschen.add(comboBox_Kalendername);

                for (String key : kalender.keySet()) {
                    comboBox_Kalendername.addItem(key);
                }

                button_Loeschen = new JButton("L\u00F6schen");
                button_Loeschen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent arg0) {

                                int fehler = 3;
                                // Abfrage ob der Nutzer wirklich löschen möchte
                                int eingabe = JOptionPane.showConfirmDialog(null,
                                        "Möchten Sie den Kalender wirklich löschen?",
                                        "Löschen Bestätigung",
                                        JOptionPane.YES_NO_OPTION);
                                if (eingabe == 0) {

                                    // Person wird an Verwaltung übergeben und es wird versucht diese zu löschen. Bei einem Fehler wird eine RE
                                    try {
                                        v.deleteKalender(kalender.get(comboBox_Kalendername.getSelectedItem()));
                                        fehler = 0;
                                    } catch (RemoteException ex) {
                                        JOptionPane.showMessageDialog(panel_KalenderLoeschen, "Der Kalender ist noch mit Kalendereinträgen verknüpft. Bitte überprüfen.");
                                        fehler = 1;
                                    }
                                }

                                if (fehler == 0) {
                                    JOptionPane.showMessageDialog(panel_KalenderLoeschen, "Kalender erfolgreich gelöscht.");
                                    zeichnePanelUebersicht();
                                }


                        }
                });
                button_Loeschen.setBounds(50, 490, 90, 20);
                panel_KalenderLoeschen.add(button_Loeschen);

                button_Abbrechen = new JButton("Abbrechen");
                button_Abbrechen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                        }
                });
                button_Abbrechen.setBounds(210, 490, 120, 20);
                panel_KalenderLoeschen.add(button_Abbrechen);

                panel_KalenderLoeschen.setVisible(true);
                panel_KalenderLoeschen.setVisible(true);
        }

        private void zeichnePanelKalendereintragErstellen()
        {
                versteckePanels();
                
                // Alle Kalender auf die wir Zugriff haben werden ausgelesen
                Vector <Kalender> unsere_kalender = new Vector();
                try {
                     // Wir lesen alle Personen aus
                     v = getVerwaltung();
                     unsere_kalender = v.getKalender_byBerechtigung(eingeloggte_person);

                 } catch (RemoteException re) {

                 }

                // Hashmap für die ComboBox der Kalenderauwahl wird erzeugt und befüllt
                kalender = new HashMap<String, Kalender>();
                for (int i = 0; i < unsere_kalender.size(); i++) {
                    try {
                        // Wir lesen den Besitzer aus und ermitteln dann den vollen Namen und die Bezeichnung, fügen diese zusammen und dann in die HashMap
                        int besitzer_id = unsere_kalender.elementAt(i).get_besitzer();
                        String voller_name = v.getPerson_byid(besitzer_id).get_voller_name();
                        String voller_name_kalenderbezeichnung = "<html><b><u>" + voller_name + "</u></b> : <br>" + unsere_kalender.elementAt(i).get_bezeichnung() + "</html>";
                        kalender.put(voller_name_kalenderbezeichnung, unsere_kalender.elementAt(i));
                    } catch (RemoteException ex) {
                    }
                }

                // Wir lesen für die HashMap bzw. ComboBox alle Personen ohne angemeldete Person aus (wichtig um Einladungen festzulegen)
                                unsere_personen = new Vector();

                try {
                     // Wir lesen alle Personen aus
                     v = getVerwaltung();
                     unsere_personen = v.getAllPerson_ohne_uebergebene_person(eingeloggte_person);

                 } catch (RemoteException re) {

                 }

                // Wir lesen die Kategorien aus 
                Vector <Kategorie> unsere_kategorien = new Vector();


                // Wir lesen alle Kategorien aus und schreiben diese in einen neuen Vektor
                 try {
                     // Wir lesen alle Personen aus
                     v = getVerwaltung();
                     unsere_kategorien = v.get_all_Kategorie();

                 } catch (RemoteException re) {

                 }

                //Hashmap für die ComboBox wird erstellt
                kategorie = new HashMap<String, Kategorie>();
                for (int i = 0; i < unsere_kategorien.size(); i++) {
                    try {
                        kategorie.put(unsere_kategorien.elementAt(i).get_name(), unsere_kategorien.elementAt(i));
                    } catch (RemoteException ex) {
                    }
                }

                panel_Hintergrund.removeAll();

                panel_KalendereintragErstellen = new JPanel();
                panel_Hintergrund.add(panel_KalendereintragErstellen, BorderLayout.CENTER);
                panel_KalendereintragErstellen.setLayout(null);

                JLabel label_KalendereintragErstellen = new JLabel("Kalendereintrag erstellen");
                label_KalendereintragErstellen.setFont(new Font("Tahoma", Font.PLAIN, 15));
                label_KalendereintragErstellen.setBounds(50, 30, 220, 30);
                panel_KalendereintragErstellen.add(label_KalendereintragErstellen);

                JLabel label_Kalenderwahl = new JLabel("Besitzer des Kalenders:");
                label_Kalenderwahl.setBounds(50, 80, 150, 20);
                panel_KalendereintragErstellen.add(label_Kalenderwahl);

                JLabel label_Besitzer = new JLabel("Kalenderbezeichnung:");
                label_Besitzer.setBounds(50, 100, 150, 20);
                panel_KalendereintragErstellen.add(label_Besitzer);

                comboBox_Kalenderwahl = new JComboBox();
                comboBox_Kalenderwahl.setBounds(210, 80, 400, 40);
                panel_KalendereintragErstellen.add(comboBox_Kalenderwahl);

                // Wir befüllen die ComboBox mit den Einträgen der HashMap kalender
                for (String key : kalender.keySet()) {
                    comboBox_Kalenderwahl.addItem(key);
                }

                JLabel label_Datum = new JLabel("Startdatum auswählen:");
                label_Datum.setBounds(50, 135, 170, 30);
                panel_KalendereintragErstellen.add(label_Datum);

                textField_startdatum = new JTextField();
                textField_startdatum.enableInputMethods(true);
                textField_startdatum.setEditable(false);
                textField_startdatum.setBounds(210, 140, 80, 20);
                panel_KalendereintragErstellen.add(textField_startdatum);

                final JFrame f = new JFrame();

                f.setTitle("Startdatum auswählen");

                f.pack();
                f.setVisible(false);
   
                button_startdatum = new JButton("Kalender öffnen");
                button_startdatum.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                            textField_startdatum.setText(new DatePicker(f).setPickedDate());
                        }
                });
                button_startdatum.setBounds(300, 140, 130, 20);
                panel_KalendereintragErstellen.add(button_startdatum);

                JLabel label_startuhrzeit = new JLabel("Startzeit wählen:");
                label_startuhrzeit.setBounds(450, 135, 170, 30);
                panel_KalendereintragErstellen.add(label_startuhrzeit);

        

                comboBox_Tag = new JComboBox();
                comboBox_Tag.setBounds(560, 140, 50, 20);
                panel_KalendereintragErstellen.add(comboBox_Tag);
                for(int i=0; i<24; i++)
                {
                    // Für 2 stellige Ausgabe in der ComboBox, wichtig auch zum parsen des Datums z.B. 1 -> 01
                    String zahl = String.format("%02d", i);
                    comboBox_Tag.addItem(zahl);
                }


                comboBox_Monat = new JComboBox();
                comboBox_Monat.setBounds(620, 140, 50, 20);
                panel_KalendereintragErstellen.add(comboBox_Monat);

                for(int i=0; i<60; i++)
                {
                     // Für 2 stellige Ausgabe in der ComboBox, wichtig auch zum parsen des Datums z.B. 1 -> 01
                    String zahl = String.format("%02d", i);
                    comboBox_Monat.addItem(zahl);
                }


                label_Enddatum = new JLabel("Enddatum auswählen:");
                label_Enddatum.setBounds(50, 170, 170, 30);
                panel_KalendereintragErstellen.add(label_Enddatum);

                textField_enddatum = new JTextField();
                textField_enddatum.enableInputMethods(true);
                textField_enddatum.setEditable(false);
                textField_enddatum.setBounds(210, 170, 80, 20);
                panel_KalendereintragErstellen.add(textField_enddatum);

                final JFrame f2 = new JFrame();

                f2.setTitle("Startdatum auswählen");

                f2.pack();
                f2.setVisible(false);

                button_enddatum = new JButton("Kalender öffnen");
                button_enddatum.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                            textField_enddatum.setText(new DatePicker(f2).setPickedDate());
                        }
                });
                button_enddatum.setBounds(300, 170, 130, 20);
                panel_KalendereintragErstellen.add(button_enddatum);

                label_enduhrzeit = new JLabel("Endzeit swählen:");
                label_enduhrzeit.setBounds(450, 165, 170, 30);
                panel_KalendereintragErstellen.add(label_enduhrzeit);



                comboBox_Tag2 = new JComboBox();
                comboBox_Tag2.setBounds(560, 170, 50, 20);
                panel_KalendereintragErstellen.add(comboBox_Tag2);
                for(int i=0; i<=23; i++)
                {
                     // Für 2 stellige Ausgabe in der ComboBox, wichtig auch zum parsen des Datums z.B. 1 -> 01
                    String zahl = String.format("%02d", i);                
                    comboBox_Tag2.addItem(zahl);
                }


                comboBox_Monat2 = new JComboBox();
                comboBox_Monat2.setBounds(620, 170, 50, 20);
                panel_KalendereintragErstellen.add(comboBox_Monat2);

                for(int i=0; i<=59; i++)
                {
                     // Für 2 stellige Ausgabe in der ComboBox, wichtig auch zum parsen des Datums z.B. 1 -> 01
                    String zahl = String.format("%02d", i);
                    comboBox_Monat2.addItem(zahl);
                }



                label_Beschreibung = new JLabel("Beschreibung:");
                label_Beschreibung.setBounds(50, 230, 150, 20);
                panel_KalendereintragErstellen.add(label_Beschreibung);

                textField_Beschreibung = new JTextField();
                textField_Beschreibung.setBounds(210, 230, 400, 20);
                panel_KalendereintragErstellen.add(textField_Beschreibung);

                label_Kategorien = new JLabel("Kategorie:");
                label_Kategorien.setBounds(50, 270, 70, 20);
                panel_KalendereintragErstellen.add(label_Kategorien);

                comboBox_Kategorien = new JComboBox();
                comboBox_Kategorien.setBounds(210, 270, 230, 20);
                panel_KalendereintragErstellen.add(comboBox_Kategorien);

                label_ort = new JLabel("Ort:");
                label_ort.setBounds(50, 300, 70, 20);
                panel_KalendereintragErstellen.add(label_ort);

                textField_ort = new JTextField();
                textField_ort.setBounds(210, 300, 400, 20);
                panel_KalendereintragErstellen.add(textField_ort);

                // Wir befüllen die ComboBox mit den Einträgen der HashMap kalender
                for (String key : kategorie.keySet()) {
                    comboBox_Kategorien.addItem(key);
                }


                comboBox_WiederholArt = new JComboBox();
                comboBox_WiederholArt.setBounds(210, 330, 150, 20);
                comboBox_WiederholArt.setVisible(false);
                comboBox_WiederholArt.addItem(new String("täglich"));
                comboBox_WiederholArt.addItem(new String("wöchentlich"));
                comboBox_WiederholArt.addItem(new String("monatlich"));
                comboBox_WiederholArt.addItem(new String("jährlich"));

                label_anzahl_wiederholung = new JLabel("Anzahl der Wiederholung:");
                label_anzahl_wiederholung.setBounds(400, 330, 170, 20);
                label_anzahl_wiederholung.setVisible(false);
                panel_KalendereintragErstellen.add(label_anzahl_wiederholung);

                anzahl_wiederholung = new JComboBox();
                anzahl_wiederholung.setBounds(560, 330, 50, 20);
                anzahl_wiederholung.setVisible(false);
                panel_KalendereintragErstellen.add(anzahl_wiederholung);
                for(int i=0; i<=10; i++)
                {
                     // Für 2 stellige Ausgabe in der ComboBox, wichtig auch zum parsen des Datums z.B. 1 -> 01

                    anzahl_wiederholung.addItem(i);
                }

                panel_KalendereintragErstellen.add(comboBox_WiederholArt);

                chckbxWiederholen = new JCheckBox("Wiederholen?");
                chckbxWiederholen.setBounds(50, 330, 150, 20);
                chckbxWiederholen.setSelected(false);
                chckbxWiederholen.addItemListener(new ItemListener() {
                        public void itemStateChanged(ItemEvent arg0) {
                                comboBox_WiederholArt.setVisible(chckbxWiederholen.isSelected());
                                anzahl_wiederholung.setVisible(chckbxWiederholen.isSelected());
                                label_anzahl_wiederholung.setVisible(chckbxWiederholen.isSelected());
                        }
                });
                panel_KalendereintragErstellen.add(chckbxWiederholen);

                chckbxTermin = new JCheckBox("<html>Teilnehmer<br>hinzufügen?</html>");
                chckbxTermin.setBounds(50, 360, 100, 40);
                chckbxTermin.setSelected(false);
                chckbxTermin.addItemListener(new ItemListener() {
                        public void itemStateChanged(ItemEvent arg0) {
                                button_teilnehmer_hinzufuegen.setVisible(chckbxTermin.isSelected());
                        }
                });
                panel_KalendereintragErstellen.add(chckbxTermin);

                button_teilnehmer_hinzufuegen = new JButton("Teilnehmer festlegen");
                button_teilnehmer_hinzufuegen.setVisible(false);
                button_teilnehmer_hinzufuegen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent arg0) {

                        // Wenn der Button gedrückt wird, geht ein neues Fenster, in dem wir die Personen die wir Einladen können festlegen
                        final JFrame teilnehmer_hinzufuegen = new JFrame();

                        teilnehmer_hinzufuegen.setTitle("Teilnehmer wählen");
                        
                        teilnehmer_hinzufuegen.setVisible(true);
                        teilnehmer_hinzufuegen.setBounds(200, 200, 220, 400);
                        teilnehmer_hinzufuegen.setResizable(false);

                        panel_teilnehmer_hinzufuegen = new JPanel();
                        panel_teilnehmer_hinzufuegen.setLayout(null);

                        teilnehmer_hinzufuegen.add(panel_teilnehmer_hinzufuegen);

                        // Wir erstellen unsere CheckBoxen + Personen
                        int y_position = 20;
                        int attempts = unsere_personen.size();
                        teilnehmer_label = new JLabel[attempts];
                        teilnehmer_checkbox = new JCheckBox[attempts];


                        for(int i=0; i< unsere_personen.size(); i++ )
                        {
                            try {

                                teilnehmer_label[i] = new JLabel(unsere_personen.elementAt(i).get_voller_name());
                                teilnehmer_label[i].setBounds(20, y_position, 180, 20);
                                teilnehmer_label[i].setVisible(true);
                                panel_teilnehmer_hinzufuegen.add(teilnehmer_label[i]);

                                teilnehmer_checkbox[i] = new JCheckBox("", false);
                                teilnehmer_checkbox[i].setBounds(150, y_position, 20, 20);
                                teilnehmer_checkbox[i].setVisible(true);
                                panel_teilnehmer_hinzufuegen.add(teilnehmer_checkbox[i]);


                                y_position = y_position + 30;

                            } catch (RemoteException ex) {
                                Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                            }

                        }

                        button_teilnehmer_bestaetigen = new JButton("Speichern");
                        button_teilnehmer_bestaetigen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                            teilnehmer_hinzufuegen.setVisible(false);
                        }
                        });
                        button_teilnehmer_bestaetigen.setBounds(20, y_position, 120, 20);
                        panel_teilnehmer_hinzufuegen.add(button_teilnehmer_bestaetigen);


                        }
                });
                button_teilnehmer_hinzufuegen.setBounds(210, 365, 200, 20);
                panel_KalendereintragErstellen.add(button_teilnehmer_hinzufuegen);

                chckbxErinnern = new JCheckBox("Erinnerung");
                chckbxErinnern.setBounds(50, 440, 100, 40);
                chckbxErinnern.setSelected(false);
                panel_KalendereintragErstellen.add(chckbxErinnern);
 
                


                button_Abbrechen = new JButton("Abbrechen");
                button_Abbrechen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                            zeichnePanelUebersicht();
                        }
                });
                button_Abbrechen.setBounds(210, 490, 120, 20);
                panel_KalendereintragErstellen.add(button_Abbrechen);

                button_Erstellen = new JButton("Erstellen");
                button_Erstellen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent arg0) {
                            // Es wird überprüft ob alle notwendigen Felder ausgefüllt wurden, falls nicht, wird ein PopUp angezeigt und der Eintrag wird nicht an die Verwaltung übergeben
                        if (textField_startdatum.getText().equals("") || textField_enddatum.getText().equals("") || textField_Beschreibung.getText().equals("")) {
                            JOptionPane.showMessageDialog(panel_KalendereintragErstellen, "Bitte alle Felder ausfüllen!");   }

                        else  {
                                // Fehler Varibale erstellen / 3 -> Initialzustand / 0 -> Kein Fehler / Alles andere -> Fehler

                                int fehler = 3;

                                // 1. StartDatum auslesen, parsen und als Timestamp abspeichern

                                // String mit allen Angaben des Startdatums bauen
                                String volles_Datum_start = textField_startdatum.getText() + " " + comboBox_Tag.getSelectedItem() + ":" + comboBox_Monat.getSelectedItem();
                                String volles_Datum_end = textField_enddatum.getText() + " " + comboBox_Tag2.getSelectedItem() + ":" + comboBox_Monat2.getSelectedItem();

                               // String wird via SimpleDateFormat geparst, da es zu Fehlern kommen kann mit try/catch Block abgefangen
                               SimpleDateFormat start_date = new SimpleDateFormat("dd-MM-yyyy HH:mm");
                               SimpleDateFormat end_date = new SimpleDateFormat("dd-MM-yyyy HH:mm");

                                    try {
                                        start_date_1 = start_date.parse(volles_Datum_start);
                                        end_date_1 = end_date.parse(volles_Datum_end);
                                    } catch (ParseException ex) {
                                        Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                    }

                               // SimpleDateFormat wird in GregorianCalendar konvertiert und daraus dann ein Timestamp erzeugt

                                    Calendar cal_start = Calendar.getInstance();
                                    cal_start.setTime(start_date_1);                    // Startzeitpunkt
                                    cal_start.set(Calendar.MILLISECOND, 0);
                                    Timestamp s = new Timestamp(cal_start.getTimeInMillis());

                                    Calendar cal_ende = Calendar.getInstance();
                                    cal_ende.setTime(end_date_1);                    // Startzeitpunkt
                                    cal_ende.set(Calendar.MILLISECOND, 0);
                                    Timestamp e = new Timestamp(cal_ende.getTimeInMillis());

                                    System.out.println(s + "   " + e);


                            if(chckbxTermin.isSelected() == false && chckbxWiederholen.isSelected() == true )
                            {
                                // Dann handelt es sich um einen normalen Kalendereintrag, Felder werden ausgelesen und an die Verwaltung übermitteln
                                // Attribute die wir für das Eintragen des Kalenders brauchen:
                                 int kategorie_id = 0;
                                 int kalender_id = 0;
                                 int besitzer_id = 0;
                                 int eintrag_id = 0; // wird in der DB automatisch überschrieben
                                 int erinnerung = 0;
                                 char wiederholung = 'z';
                                 int anzahl_wiederholung_int = Integer.parseInt(anzahl_wiederholung.getSelectedItem().toString());
                                 System.out.println(anzahl_wiederholung_int);

                                 // Auslesen der ComboBox Wiederholung und setzen des Chars
                                 if(comboBox_WiederholArt.getSelectedItem().equals("täglich"))
                                     wiederholung = 't';
                                 else if(comboBox_WiederholArt.getSelectedItem().equals("wöchentlich"))
                                     wiederholung = 'w';
                                 else if(comboBox_WiederholArt.getSelectedItem().equals("monatlich"))
                                     wiederholung = 'm';
                                 else
                                     wiederholung = 'y';
                                                 
                                 String ort = textField_ort.getText();
                                 String beschreibung = textField_Beschreibung.getText();
                                    try {
                                        kategorie_id = kategorie.get(comboBox_Kategorien.getSelectedItem()).get_kategorie_id();
                                        kalender_id = kalender.get(comboBox_Kalenderwahl.getSelectedItem()).get_kalender_id();
                                        besitzer_id = kalender.get(comboBox_Kalenderwahl.getSelectedItem()).get_besitzer();
                                    } catch (RemoteException ex) {
                                        Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                    }
                                 if(chckbxErinnern.isSelected())
                                     erinnerung = 1;
                                 
                                        try {
                                            // Kalendereintrag wird an die Verwaltung übergeben, dort geprüft und bei Erfolg in die DB geschrieben
                                            v.createWiederholung(s, e, ort, beschreibung, kategorie_id, erinnerung, besitzer_id, eintrag_id, kalender_id, anzahl_wiederholung_int, wiederholung);
                                            fehler = 0;
                                        } catch (RemoteException ex) {
                                           JOptionPane.showMessageDialog(panel_KalendereintragErstellen, ex.getCause().toString().substring(26));
                                           fehler = 1;
                                        }
                                 if (fehler == 0) {
                                    JOptionPane.showMessageDialog(panel_KalendereintragErstellen, "Kalendereintrag " + beschreibung + " erfolgreich angelegt.");
                                    zeichnePanelUebersicht();
                                 }

                            }
                            else if(chckbxTermin.isSelected() == false && chckbxWiederholen.isSelected() == false )
                            {
                                // Dann handelt es sich um einen normalen Kalendereintrag, Felder werden ausgelesen und an die Verwaltung übermitteln
                                // Attribute die wir für das Eintragen des Kalenders brauchen:
                                 int kategorie_id = 0;
                                 int kalender_id = 0;
                                 int besitzer_id = 0;
                                 int eintrag_id = 0; // wird in der DB automatisch überschrieben
                                 int erinnerung = 0;
                                 String ort = textField_ort.getText();
                                 String beschreibung = textField_Beschreibung.getText();
                                    try {
                                        kategorie_id = kategorie.get(comboBox_Kategorien.getSelectedItem()).get_kategorie_id();
                                        kalender_id = kalender.get(comboBox_Kalenderwahl.getSelectedItem()).get_kalender_id();
                                        besitzer_id = kalender.get(comboBox_Kalenderwahl.getSelectedItem()).get_besitzer();
                                    } catch (RemoteException ex) {
                                        Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                    }
                                 if(chckbxErinnern.isSelected())
                                     erinnerung = 1;

                                        try {
                                            // Kalendereintrag wird an die Verwaltung übergeben, dort geprüft und bei Erfolg in die DB geschrieben
                                            v.createKalendereintrag(s, e, ort, beschreibung, kategorie_id, erinnerung, besitzer_id, eintrag_id, kalender_id);
                                            fehler = 0;
                                        } catch (RemoteException ex) {
                                           JOptionPane.showMessageDialog(panel_KalendereintragErstellen, ex.getCause().toString().substring(26));
                                           fehler = 1;
                                        }
                                 if (fehler == 0) {
                                    JOptionPane.showMessageDialog(panel_KalendereintragErstellen, "Kalendereintrag " + beschreibung + " erfolgreich angelegt.");
                                    zeichnePanelUebersicht();
                                 }

                            }
                            else if(chckbxTermin.isSelected() == true && chckbxWiederholen.isSelected() == false )
                            {
                                // Dann handelt es sich um einen normalen Kalendereintrag mit Termin und ohne Wiederholung, Felder werden ausgelesen und an die Verwaltung übermitteln
                                // Attribute die wir für das Eintragen des Kalenders brauchen:
                                 int kategorie_id = 0;
                                 int kalender_id = 0;
                                 int besitzer_id = 0;
                                 int eintrag_id = 0; // wird in der DB automatisch überschrieben
                                 int erinnerung = 0;
                                 int anzahl = 0;
                                 char serienmuster = 'k'; // wird gesetzt da es sich um einen normalen Eintrag handelt (ohne Wiederholung)
                                 int wiederholung_id;
                                 String ort = textField_ort.getText();
                                 String beschreibung = textField_Beschreibung.getText();
                                    try {
                                        kategorie_id = kategorie.get(comboBox_Kategorien.getSelectedItem()).get_kategorie_id();
                                        kalender_id = kalender.get(comboBox_Kalenderwahl.getSelectedItem()).get_kalender_id();
                                        besitzer_id = kalender.get(comboBox_Kalenderwahl.getSelectedItem()).get_besitzer();
                                    } catch (RemoteException ex) {
                                        Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                    }

                                 // Der Vector mit den eingeladenen Personen wird erstellt
                                 Vector <Person> teilnehmer_vector = new Vector<Person>();

                                 // Es werden alle Personen ausgelesen und einen zusätzlichen Vector geschrieben
                                 int anzahl_personen = 0;
                                            try {
                                                anzahl_personen = v.getAllPerson_ohne_uebergebene_person(eingeloggte_person).size();
                                            } catch (RemoteException ex) {
                                                Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                            }

                                 // Nun wird überprüft welche Teilnehmer angeklickt wurden, diese werden dem Vector hinzugefügt
                                 for(int i=0; i< anzahl_personen; i++ )
                                   {
                                       int person_id = 0;
                                            try {
                                                //Wir lesen die Person_ID aus
                                                Person x = v.getAllPerson_ohne_uebergebene_person(eingeloggte_person).elementAt(i);
                                                person_id = x.get_person_id();
                                            } catch (RemoteException ex) {
                                                Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                            }

                                        if(teilnehmer_checkbox[i].isSelected()){
                                            try {
                                                teilnehmer_vector.add(v.getPerson_byid(person_id));
                                            } catch (RemoteException ex) {
                                                Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                            }
                                       }

                                       else {
                                            try {
                                                System.out.println("Person " + v.getPerson_byid(person_id).get_voller_name() + " bekommt keine Einladung");
                                            } catch (RemoteException ex) {
                                                Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                            }
                                       }


                                        }




                                 if(chckbxErinnern.isSelected())
                                     erinnerung = 1;

                                        try {
                                            // Termin wird an die Verwaltung übergeben, dort geprüft und bei Erfolg in die DB geschrieben
                                            v.createTermin(s, e, ort, beschreibung, kategorie_id, erinnerung, besitzer_id, eintrag_id, kalender_id, anzahl, serienmuster, teilnehmer_vector);
                                           
                                            fehler = 0;
                                        } catch (RemoteException ex) {
                                           JOptionPane.showMessageDialog(panel_KalendereintragErstellen, ex.getCause().toString().substring(26));
                                           fehler = 1;
                                        }
                                 if (fehler == 0) {
                                    JOptionPane.showMessageDialog(panel_KalendereintragErstellen, "Kalendereintrag " + beschreibung + " erfolgreich angelegt.");
                                    zeichnePanelUebersicht();
                                 }
                            }
                            else if(chckbxTermin.isSelected() == true && chckbxWiederholen.isSelected() == true )
                            {
                                // Dann handelt es sich um einen Termin, der einer Wiederholung zu Grunde liegt
                                // Attribute die wir für das Eintragen des Kalenders brauchen:
                                 int kategorie_id = 0;
                                 int kalender_id = 0;
                                 int besitzer_id = 0;
                                 int eintrag_id = 0; // wird in der DB automatisch überschrieben
                                 int erinnerung = 0;
                                 int anzahl = Integer.parseInt(anzahl_wiederholung.getSelectedItem().toString());
                                 char serienmuster = 'w'; // wird gesetzt da es sich um einen normalen Eintrag handelt (ohne Wiederholung)
                                 int wiederholung_id;

                                 // Auslesen der ComboBox Wiederholung und setzen des Chars
                                 if(comboBox_WiederholArt.getSelectedItem().equals("täglich"))
                                     serienmuster = 't';
                                 else if(comboBox_WiederholArt.getSelectedItem().equals("wöchentlich"))
                                     serienmuster = 'w';
                                 else if(comboBox_WiederholArt.getSelectedItem().equals("monatlich"))
                                     serienmuster = 'm';
                                 else
                                     serienmuster = 'y';

                                 String ort = textField_ort.getText();
                                 String beschreibung = textField_Beschreibung.getText();
                                    try {
                                        kategorie_id = kategorie.get(comboBox_Kategorien.getSelectedItem()).get_kategorie_id();
                                        kalender_id = kalender.get(comboBox_Kalenderwahl.getSelectedItem()).get_kalender_id();
                                        besitzer_id = kalender.get(comboBox_Kalenderwahl.getSelectedItem()).get_besitzer();
                                    } catch (RemoteException ex) {
                                        Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                    }

                                 // Der Vector mit den eingeladenen Personen wird erstellt
                                 Vector <Person> teilnehmer_vector = new Vector<Person>();

                                 // Es werden alle Personen ausgelesen und einen zusätzlichen Vector geschrieben
                                 int anzahl_personen = 0;
                                            try {
                                                anzahl_personen = v.getAllPerson_ohne_uebergebene_person(eingeloggte_person).size();
                                            } catch (RemoteException ex) {
                                                Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                            }

                                 // Nun wird überprüft welche Teilnehmer angeklickt wurden, diese werden dem Vector hinzugefügt
                                 for(int i=0; i< anzahl_personen; i++ )
                                   {
                                       int person_id = 0;
                                            try {
                                                //Wir lesen die Person_ID aus
                                                Person x = v.getAllPerson_ohne_uebergebene_person(eingeloggte_person).elementAt(i);
                                                person_id = x.get_person_id();
                                            } catch (RemoteException ex) {
                                                Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                            }

                                        if(teilnehmer_checkbox[i].isSelected()){
                                            try {
                                                teilnehmer_vector.add(v.getPerson_byid(person_id));
                                            } catch (RemoteException ex) {
                                                Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                            }
                                       }

                                       else {
                                            try {
                                                System.out.println("Person " + v.getPerson_byid(person_id).get_voller_name() + " bekommt keine Einladung");
                                            } catch (RemoteException ex) {
                                                Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                            }
                                       }


                                        }




                                 if(chckbxErinnern.isSelected())
                                     erinnerung = 1;

                                        try {
                                            // Termin wird an die Verwaltung übergeben, dort geprüft und bei Erfolg in die DB geschrieben
                                            v.createTermin(s, e, ort, beschreibung, kategorie_id, erinnerung, besitzer_id, eintrag_id, kalender_id, anzahl, serienmuster, teilnehmer_vector);

                                            fehler = 0;
                                        } catch (RemoteException ex) {
                                           JOptionPane.showMessageDialog(panel_KalendereintragErstellen, ex.getCause().toString().substring(26));
                                           fehler = 1;
                                        }
                                 if (fehler == 0) {
                                    JOptionPane.showMessageDialog(panel_KalendereintragErstellen, "Kalendereintrag " + beschreibung + " erfolgreich angelegt.");
                                    zeichnePanelUebersicht();
                                 }
                            }

                        }
                     }
                });
                button_Erstellen.setBounds(50, 490, 90, 20);
                panel_KalendereintragErstellen.add(button_Erstellen);

                panel_KalendereintragErstellen.setVisible(true);
        }

        private void zeichnePanelKalendereintragBearbeiten()
        {
                versteckePanels();



                // Wir initialisieren die für die Auslesefunktion wichtigen Vectoren und Hashmaps
                unsere_kategorien = new Vector();
                unsere_kalendereintraege = new Vector();
                unsere_wiederholungen = new Vector();
                unsere_termine = new Vector();
                unsere_termin_wiederholung = new Vector();
                //kalendereintrag = new HashMap<String, Kalendereintrag>();

                // Wir lesen alle Kategorien, Kalendereinträge aus und schreiben diese in einen neuen Vektor
                 try {
                     // Wir lesen alle Kategorien aus
                     v = getVerwaltung();
                     unsere_kategorien = v.get_all_Kategorie();
                     unsere_kalendereintraege = v.get_kalendereintraege_by_person(eingeloggte_person);
                     unsere_wiederholungen = v.get_wiederholungen_by_person(eingeloggte_person);
                     unsere_termine = v.get_termine_by_person(eingeloggte_person);
                     unsere_personen = v.getAllPerson_ohne_uebergebene_person(eingeloggte_person);
                     unsere_termin_wiederholung = v.get_wiederholung_termine_by_person(eingeloggte_person);

                 } catch (RemoteException re) {

                 }

                //Hashmap für die ComboBox der Kateogiren wird erstellt
                kategorie = new HashMap<String, Kategorie>();
                for (int i = 0; i < unsere_kategorien.size(); i++) {
                    try {
                        kategorie.put(unsere_kategorien.elementAt(i).get_name(), unsere_kategorien.elementAt(i));
                    } catch (RemoteException ex) {
                    }
                }



                panel_Hintergrund.removeAll();

                

                panel_KalendereintragAendern = new JPanel();
                panel_Hintergrund.add(panel_KalendereintragAendern, BorderLayout.CENTER);
                panel_KalendereintragAendern.setLayout(null);

                label_filter = new JLabel("Filter wählen:");
                label_filter.setBounds(50, 75, 100, 20);
                panel_KalendereintragAendern.add(label_filter);

                chckbxKalendereintrag = new JCheckBox("Kalendereinträge");
                chckbxKalendereintrag.setBounds(210, 65, 150, 40);
                chckbxKalendereintrag.setSelected(false);
                chckbxKalendereintrag.addItemListener (new ItemListener() {
                        public void itemStateChanged(ItemEvent e) {
                            initKalendereintrag();
                        }
                });
                panel_KalendereintragAendern.add(chckbxKalendereintrag);

                chckbxWiederholung = new JCheckBox("Wiederholung");
                chckbxWiederholung.setBounds(360, 65, 150, 40);
                chckbxWiederholung.setSelected(false);
                chckbxWiederholung.addItemListener(new ItemListener() {
                        public void itemStateChanged(ItemEvent e) {
                            initWiederholungeintrag();
                        }
                });
                panel_KalendereintragAendern.add(chckbxWiederholung);

                chckbxTermine = new JCheckBox("Termine");
                chckbxTermine.setBounds(510, 65, 100, 40);
                chckbxTermine.setSelected(false);
                chckbxTermine.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                            initTermin();
                        }
                });
                panel_KalendereintragAendern.add(chckbxTermine);

                chckbxTerminWiederholung = new JCheckBox("Termin mit Wiederholung");
                chckbxTerminWiederholung.setBounds(610, 65, 170, 40);
                chckbxTerminWiederholung.setSelected(false);
                chckbxTerminWiederholung.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                            initTerminWiederholung();

                        }
                });
                panel_KalendereintragAendern.add(chckbxTerminWiederholung);

               
                ButtonGroup filter = new ButtonGroup();
                filter.add(chckbxKalendereintrag);
                filter.add(chckbxWiederholung);
                filter.add(chckbxTerminWiederholung);
                filter.add(chckbxTermine);

                JLabel label_KalendereintragErstellen = new JLabel("Kalendereintrag bearbeiten");
                label_KalendereintragErstellen.setFont(new Font("Tahoma", Font.PLAIN, 15));
                label_KalendereintragErstellen.setBounds(50, 30, 220, 30);
                panel_KalendereintragAendern.add(label_KalendereintragErstellen);

                JLabel label_Kalenderwahl = new JLabel("Kalenderbezeichnung:");
                label_Kalenderwahl.setBounds(50, 110, 150, 20);
                panel_KalendereintragAendern.add(label_Kalenderwahl);

                JLabel label_Besitzer = new JLabel("Beschreibung / Ort:");
                label_Besitzer.setBounds(50, 130, 150, 20);
                panel_KalendereintragAendern.add(label_Besitzer);

                comboBox_Eintrag = new JComboBox();
                comboBox_Eintrag.setBounds(210, 110, 400, 40);
                comboBox_Eintrag.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                            if(comboBox_Eintrag.getItemCount() != 0) //Abfangen von leerer ComboBoxen -> nach dem removeallitems
                            {
                            if(chckbxKalendereintrag.isSelected())
                            {
                                try {
                                // Ausblenden der nicht benötigten Elemente und setzen der Defaultwerte
                                anzahl_wiederholung.setVisible(false);
                                comboBox_WiederholArt.setVisible(false);
                                label_anzahl_wiederholung.setVisible(false);
                                chckbxErinnern.setSelected(false);
                                chckbxTermin.setSelected(false);
                                button_teilnehmer_hinzufuegen.setVisible(false);

                                // Wir holen den ausgewählten Kalendereintrag
                                textField_Beschreibung.setText(kalendereintrag.get(comboBox_Eintrag.getSelectedItem()).get_beschreibung());
                                textField_Beschreibung.updateUI();
                                textField_ort.setText(kalendereintrag.get(comboBox_Eintrag.getSelectedItem()).get_ort());
                                textField_ort.updateUI();

                                //Setzen des Datums
                                String s = new SimpleDateFormat("dd-MM-yyyy").format(kalendereintrag.get(comboBox_Eintrag.getSelectedItem()).get_start());
                                textField_startdatum.setText(s);
                                s = new SimpleDateFormat("dd-MM-yyyy").format(kalendereintrag.get(comboBox_Eintrag.getSelectedItem()).get_ende());
                                textField_enddatum.setText(s);

                                //Setzen der Uhrzeit
                                s = new SimpleDateFormat("HH").format(kalendereintrag.get(comboBox_Eintrag.getSelectedItem()).get_start());
                                comboBox_Tag.setSelectedItem(s);
                                s = new SimpleDateFormat("mm").format(kalendereintrag.get(comboBox_Eintrag.getSelectedItem()).get_start());
                                comboBox_Monat.setSelectedItem(s);
                                s = new SimpleDateFormat("HH").format(kalendereintrag.get(comboBox_Eintrag.getSelectedItem()).get_ende());
                                comboBox_Tag2.setSelectedItem(s);
                                s = new SimpleDateFormat("mm").format(kalendereintrag.get(comboBox_Eintrag.getSelectedItem()).get_ende());
                                comboBox_Monat2.setSelectedItem(s);

                                // Checkbox Erinnerung auslesen
                                if(kalendereintrag.get(comboBox_Eintrag.getSelectedItem()).get_erinnerung() == 1)
                                    chckbxErinnern.setSelected(true);
                                else
                                    chckbxErinnern.setSelected(false);


                            } catch (RemoteException ex) {
                                Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                            }
                            }
                            if(chckbxWiederholung.isSelected())
                            {
                                try {

                                // Ausblenden der nicht benötigten Elemente und setzen der Defaultwerte
                                anzahl_wiederholung.setVisible(true);
                                comboBox_WiederholArt.setVisible(true);
                                label_anzahl_wiederholung.setVisible(true);
                                chckbxErinnern.setSelected(false);
                                chckbxTermin.setSelected(false);
                                button_teilnehmer_hinzufuegen.setVisible(false);
                                
                                // Wir holen die ausgewählte Wiederholung
                                textField_Beschreibung.setText(wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_beschreibung());
                                textField_ort.setText(wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_ort());

                                //Setzen des Datums
                                String s = new SimpleDateFormat("dd-MM-yyyy").format(wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_start());
                                textField_startdatum.setText(s);
                                s = new SimpleDateFormat("dd-MM-yyyy").format(wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_ende());
                                textField_enddatum.setText(s);

                                //Setzen der Uhrzeit
                                s = new SimpleDateFormat("HH").format(wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_start());
                                comboBox_Tag.setSelectedItem(s);
                                s = new SimpleDateFormat("mm").format(wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_start());
                                comboBox_Monat.setSelectedItem(s);
                                s = new SimpleDateFormat("HH").format(wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_ende());
                                comboBox_Tag2.setSelectedItem(s);
                                s = new SimpleDateFormat("mm").format(wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_ende());
                                comboBox_Monat2.setSelectedItem(s);

                                // Checkbox Erinnerung auslesen
                                if(wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_erinnerung() == 1)
                                    chckbxErinnern.setSelected(true);
                                else
                                    chckbxErinnern.setSelected(false);

                                // Wiederholung Checkbox wird gesetzt
                                chckbxWiederholen.setSelected(true);

                                // Anzahl der Tage auslesen und setzen
                                anzahl_wiederholung.setSelectedItem(wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_anzahl());


                                // Auslesen der ComboBox Wiederholung und setzen des Chars
                                 if(wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_serienmuster() == 't')
                                     comboBox_WiederholArt.setSelectedItem("täglich");
                                 else if(wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_serienmuster() == 'w')
                                     comboBox_WiederholArt.setSelectedItem("wöchentlich");
                                 else if(wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_serienmuster() == 'm')
                                     comboBox_WiederholArt.setSelectedItem("monatlich");
                                 else
                                     comboBox_WiederholArt.setSelectedItem("jährlich");

                                // Checkbox Erinnerung auslesen
                                if(wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_erinnerung() == 1)
                                    chckbxErinnern.setSelected(true);
                                else
                                    chckbxErinnern.setSelected(false);

                            } catch (RemoteException ex) {
                                Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                            }
                            }
                            if(chckbxTermine.isSelected())
                            {
                                try {
                                // Ausblenden der nicht benötigten Elemente und setzen der Defaultwerte
                                anzahl_wiederholung.setVisible(false);
                                comboBox_WiederholArt.setVisible(false);
                                label_anzahl_wiederholung.setVisible(false);
                                chckbxTermin.setSelected(true);
                                button_teilnehmer_hinzufuegen.setVisible(true);                                

                                // Wir holen den ausgewählten Kalendereintrag
                                textField_Beschreibung.setText(termine.get(comboBox_Eintrag.getSelectedItem()).get_beschreibung());
                                textField_Beschreibung.updateUI();
                                textField_ort.setText(termine.get(comboBox_Eintrag.getSelectedItem()).get_ort());
                                textField_ort.updateUI();

                                //Setzen des Datums
                                String s = new SimpleDateFormat("dd-MM-yyyy").format(termine.get(comboBox_Eintrag.getSelectedItem()).get_start());
                                textField_startdatum.setText(s);
                                s = new SimpleDateFormat("dd-MM-yyyy").format(termine.get(comboBox_Eintrag.getSelectedItem()).get_ende());
                                textField_enddatum.setText(s);

                                //Setzen der Uhrzeit
                                s = new SimpleDateFormat("HH").format(termine.get(comboBox_Eintrag.getSelectedItem()).get_start());
                                comboBox_Tag.setSelectedItem(s);
                                s = new SimpleDateFormat("mm").format(termine.get(comboBox_Eintrag.getSelectedItem()).get_start());
                                comboBox_Monat.setSelectedItem(s);
                                s = new SimpleDateFormat("HH").format(termine.get(comboBox_Eintrag.getSelectedItem()).get_ende());
                                comboBox_Tag2.setSelectedItem(s);
                                s = new SimpleDateFormat("mm").format(termine.get(comboBox_Eintrag.getSelectedItem()).get_ende());
                                comboBox_Monat2.setSelectedItem(s);

                                // Checkbox Erinnerung auslesen
                                if(termine.get(comboBox_Eintrag.getSelectedItem()).get_erinnerung() == 1)
                                    chckbxErinnern.setSelected(true);
                                else
                                    chckbxErinnern.setSelected(false);


                            } catch (RemoteException ex) {
                                Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                            }
                            }
                            if(chckbxTerminWiederholung.isSelected())
                            {
                                try {

                                // Ausblenden der nicht benötigten Elemente und setzen der Defaultwerte
                                anzahl_wiederholung.setVisible(true);
                                comboBox_WiederholArt.setVisible(true);
                                label_anzahl_wiederholung.setVisible(true);
                                chckbxErinnern.setSelected(false);
                                chckbxTermin.setSelected(true);
                                button_teilnehmer_hinzufuegen.setVisible(true);

                                // Wir holen die ausgewählte Wiederholung
                                textField_Beschreibung.setText(termin_wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_beschreibung());
                                textField_ort.setText(termin_wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_ort());

                                //Setzen des Datums
                                String s = new SimpleDateFormat("dd-MM-yyyy").format(termin_wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_start());
                                textField_startdatum.setText(s);
                                s = new SimpleDateFormat("dd-MM-yyyy").format(termin_wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_ende());
                                textField_enddatum.setText(s);

                                //Setzen der Uhrzeit
                                s = new SimpleDateFormat("HH").format(termin_wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_start());
                                comboBox_Tag.setSelectedItem(s);
                                s = new SimpleDateFormat("mm").format(termin_wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_start());
                                comboBox_Monat.setSelectedItem(s);
                                s = new SimpleDateFormat("HH").format(termin_wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_ende());
                                comboBox_Tag2.setSelectedItem(s);
                                s = new SimpleDateFormat("mm").format(termin_wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_ende());
                                comboBox_Monat2.setSelectedItem(s);

                                // Checkbox Erinnerung auslesen
                                if(termin_wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_erinnerung() == 1)
                                    chckbxErinnern.setSelected(true);
                                else
                                    chckbxErinnern.setSelected(false);

                                // Wiederholung Checkbox wird gesetzt
                                chckbxWiederholen.setSelected(true);

                                // Anzahl der Tage auslesen und setzen
                                anzahl_wiederholung.setSelectedItem(termin_wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_anzahl());


                                // Auslesen der ComboBox Wiederholung und setzen des Chars
                                 if(termin_wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_serienmuster() == 't')
                                     comboBox_WiederholArt.setSelectedItem("täglich");
                                 else if(termin_wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_serienmuster() == 'w')
                                     comboBox_WiederholArt.setSelectedItem("wöchentlich");
                                 else if(termin_wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_serienmuster() == 'm')
                                     comboBox_WiederholArt.setSelectedItem("monatlich");
                                 else
                                     comboBox_WiederholArt.setSelectedItem("jährlich");

                                // Checkbox Erinnerung auslesen
                                if(termin_wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_erinnerung() == 1)
                                    chckbxErinnern.setSelected(true);
                                else
                                    chckbxErinnern.setSelected(false);

                            } catch (RemoteException ex) {
                                Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                            }
                            }
                            }

                        }
                });
                panel_KalendereintragAendern.add(comboBox_Eintrag);



                JLabel label_Datum = new JLabel("Startdatum auswählen:");
                label_Datum.setBounds(50, 165, 170, 30);
                panel_KalendereintragAendern.add(label_Datum);

                textField_startdatum = new JTextField();
                textField_startdatum.enableInputMethods(true);
                textField_startdatum.setEditable(false);
                textField_startdatum.setBounds(210, 170, 80, 20);
                panel_KalendereintragAendern.add(textField_startdatum);

                final JFrame f = new JFrame();

                f.setTitle("Startdatum auswählen");

                f.pack();
                f.setVisible(false);

                button_startdatum = new JButton("Kalender öffnen");
                button_startdatum.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                            textField_startdatum.setText(new DatePicker(f).setPickedDate());
                        }
                });
                button_startdatum.setBounds(300, 170, 130, 20);
                panel_KalendereintragAendern.add(button_startdatum);

                JLabel label_startuhrzeit = new JLabel("Startzeit wählen:");
                label_startuhrzeit.setBounds(450, 165, 170, 30);
                panel_KalendereintragAendern.add(label_startuhrzeit);



                comboBox_Tag = new JComboBox();
                comboBox_Tag.setBounds(560, 170, 50, 20);
                panel_KalendereintragAendern.add(comboBox_Tag);
                for(int i=0; i<24; i++)
                {
                    // Für 2 stellige Ausgabe in der ComboBox, wichtig auch zum parsen des Datums z.B. 1 -> 01
                    String zahl = String.format("%02d", i);
                    comboBox_Tag.addItem(zahl);
                }


                comboBox_Monat = new JComboBox();
                comboBox_Monat.setBounds(620, 170, 50, 20);
                panel_KalendereintragAendern.add(comboBox_Monat);

                for(int i=0; i<60; i++)
                {
                     // Für 2 stellige Ausgabe in der ComboBox, wichtig auch zum parsen des Datums z.B. 1 -> 01
                    String zahl = String.format("%02d", i);
                    comboBox_Monat.addItem(zahl);
                }


                label_Enddatum = new JLabel("Enddatum auswählen:");
                label_Enddatum.setBounds(50, 200, 170, 30);
                panel_KalendereintragAendern.add(label_Enddatum);

                textField_enddatum = new JTextField();
                textField_enddatum.enableInputMethods(true);
                textField_enddatum.setEditable(false);
                textField_enddatum.setBounds(210, 200, 80, 20);
                panel_KalendereintragAendern.add(textField_enddatum);

                final JFrame f2 = new JFrame();

                f2.setTitle("Startdatum auswählen");

                f2.pack();
                f2.setVisible(false);

                button_enddatum = new JButton("Kalender öffnen");
                button_enddatum.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                            textField_enddatum.setText(new DatePicker(f2).setPickedDate());
                        }
                });
                button_enddatum.setBounds(300, 200, 130, 20);
                panel_KalendereintragAendern.add(button_enddatum);

                label_enduhrzeit = new JLabel("Endzeit swählen:");
                label_enduhrzeit.setBounds(450, 195, 170, 30);
                panel_KalendereintragAendern.add(label_enduhrzeit);



                comboBox_Tag2 = new JComboBox();
                comboBox_Tag2.setBounds(560, 200, 50, 20);
                panel_KalendereintragAendern.add(comboBox_Tag2);
                for(int i=0; i<=23; i++)
                {
                     // Für 2 stellige Ausgabe in der ComboBox, wichtig auch zum parsen des Datums z.B. 1 -> 01
                    String zahl = String.format("%02d", i);
                    comboBox_Tag2.addItem(zahl);
                }


                comboBox_Monat2 = new JComboBox();
                comboBox_Monat2.setBounds(620, 200, 50, 20);
                panel_KalendereintragAendern.add(comboBox_Monat2);

                for(int i=0; i<=59; i++)
                {
                     // Für 2 stellige Ausgabe in der ComboBox, wichtig auch zum parsen des Datums z.B. 1 -> 01
                    String zahl = String.format("%02d", i);
                    comboBox_Monat2.addItem(zahl);
                }



                label_Beschreibung = new JLabel("Beschreibung:");
                label_Beschreibung.setBounds(50, 260, 150, 20);
                panel_KalendereintragAendern.add(label_Beschreibung);

                textField_Beschreibung = new JTextField();
                textField_Beschreibung.setBounds(210, 260, 400, 20);
                panel_KalendereintragAendern.add(textField_Beschreibung);

                label_Kategorien = new JLabel("Kategorie:");
                label_Kategorien.setBounds(50, 300, 70, 20);
                panel_KalendereintragAendern.add(label_Kategorien);

                comboBox_Kategorien = new JComboBox();
                comboBox_Kategorien.setBounds(210, 300, 230, 20);
                panel_KalendereintragAendern.add(comboBox_Kategorien);

                label_ort = new JLabel("Ort:");
                label_ort.setBounds(50, 330, 70, 20);
                panel_KalendereintragAendern.add(label_ort);

                textField_ort = new JTextField();
                textField_ort.setBounds(210, 330, 400, 20);
                panel_KalendereintragAendern.add(textField_ort);

                // Wir befüllen die ComboBox mit den Einträgen der HashMap kalender
                for (String key : kategorie.keySet()) {
                    comboBox_Kategorien.addItem(key);
                }


                comboBox_WiederholArt = new JComboBox();
                comboBox_WiederholArt.setBounds(210, 360, 150, 20);
                comboBox_WiederholArt.setVisible(false);
                comboBox_WiederholArt.addItem(new String("täglich"));
                comboBox_WiederholArt.addItem(new String("wöchentlich"));
                comboBox_WiederholArt.addItem(new String("monatlich"));
                comboBox_WiederholArt.addItem(new String("jährlich"));

                label_anzahl_wiederholung = new JLabel("Anzahl der Wiederholung:");
                label_anzahl_wiederholung.setBounds(400, 360, 170, 20);
                label_anzahl_wiederholung.setVisible(false);
                panel_KalendereintragAendern.add(label_anzahl_wiederholung);

                anzahl_wiederholung = new JComboBox();
                anzahl_wiederholung.setBounds(560, 360, 50, 20);
                anzahl_wiederholung.setVisible(false);
                panel_KalendereintragAendern.add(anzahl_wiederholung);
                for(int i=0; i<=10; i++)
                {
                     // Für 2 stellige Ausgabe in der ComboBox, wichtig auch zum parsen des Datums z.B. 1 -> 01

                    anzahl_wiederholung.addItem(i);
                }

                panel_KalendereintragAendern.add(comboBox_WiederholArt);

                chckbxWiederholen = new JCheckBox("Wiederholen?");
                chckbxWiederholen.setBounds(50, 360, 150, 20);
                chckbxWiederholen.setSelected(false);
                chckbxWiederholen.addItemListener(new ItemListener() {
                        public void itemStateChanged(ItemEvent arg0) {
                                comboBox_WiederholArt.setVisible(chckbxWiederholen.isSelected());
                                anzahl_wiederholung.setVisible(chckbxWiederholen.isSelected());
                                label_anzahl_wiederholung.setVisible(chckbxWiederholen.isSelected());
                        }
                });
                panel_KalendereintragAendern.add(chckbxWiederholen);

                chckbxTermin = new JCheckBox("<html>Teilnehmer<br>hinzufügen?</html>");
                chckbxTermin.setBounds(50, 390, 100, 40);
                chckbxTermin.setSelected(false);
                chckbxTermin.addItemListener(new ItemListener() {
                        public void itemStateChanged(ItemEvent arg0) {
                                button_teilnehmer_hinzufuegen.setVisible(chckbxTermin.isSelected());
                        }
                });
                panel_KalendereintragAendern.add(chckbxTermin);

                button_teilnehmer_hinzufuegen = new JButton("Teilnehmer festlegen");
                button_teilnehmer_hinzufuegen.setVisible(false);
                button_teilnehmer_hinzufuegen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent arg0) {

                        // Wenn der Button gedrückt wird, geht ein neues Fenster, in dem wir die Personen die wir Einladen können festlegen
                        final JFrame teilnehmer_hinzufuegen = new JFrame();

                        teilnehmer_hinzufuegen.setTitle("Teilnehmer wählen");

                        teilnehmer_hinzufuegen.setVisible(true);
                        teilnehmer_hinzufuegen.setBounds(200, 200, 220, 400);
                        teilnehmer_hinzufuegen.setResizable(false);

                        panel_teilnehmer_hinzufuegen = new JPanel();
                        panel_teilnehmer_hinzufuegen.setLayout(null);

                        teilnehmer_hinzufuegen.add(panel_teilnehmer_hinzufuegen);

                        // Wir erstellen unsere CheckBoxen + Personen
                        int y_position = 20;
                        int attempts = unsere_personen.size();
                        teilnehmer_label = new JLabel[attempts];
                        teilnehmer_checkbox = new JCheckBox[attempts];


                        for(int i=0; i< unsere_personen.size(); i++ )
                        {
                            try {

                                teilnehmer_label[i] = new JLabel(unsere_personen.elementAt(i).get_voller_name());
                                teilnehmer_label[i].setBounds(20, y_position, 180, 20);
                                teilnehmer_label[i].setVisible(true);
                                panel_teilnehmer_hinzufuegen.add(teilnehmer_label[i]);

                                teilnehmer_checkbox[i] = new JCheckBox("", false);
                                teilnehmer_checkbox[i].setBounds(150, y_position, 20, 20);
                                teilnehmer_checkbox[i].setVisible(true);
                                panel_teilnehmer_hinzufuegen.add(teilnehmer_checkbox[i]);


                                y_position = y_position + 30;

                            } catch (RemoteException ex) {
                                Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                            }

                        }

                        button_teilnehmer_bestaetigen = new JButton("Speichern");
                        button_teilnehmer_bestaetigen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                            teilnehmer_hinzufuegen.setVisible(false);
                        }
                        });
                        button_teilnehmer_bestaetigen.setBounds(20, y_position, 120, 20);
                        panel_teilnehmer_hinzufuegen.add(button_teilnehmer_bestaetigen);


                        }
                });
                button_teilnehmer_hinzufuegen.setBounds(210, 395, 200, 20);
                panel_KalendereintragAendern.add(button_teilnehmer_hinzufuegen);

                chckbxErinnern = new JCheckBox("Erinnerung");
                chckbxErinnern.setBounds(50, 440, 100, 40);
                chckbxErinnern.setSelected(false);
                panel_KalendereintragAendern.add(chckbxErinnern);




                button_Abbrechen = new JButton("Abbrechen");
                button_Abbrechen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                            zeichnePanelUebersicht();
                        }
                });
                button_Abbrechen.setBounds(210, 490, 120, 20);
                panel_KalendereintragAendern.add(button_Abbrechen);

                button_Erstellen = new JButton("Ändern");
                button_Erstellen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent arg0) {
                            // Es wird überprüft ob alle notwendigen Felder ausgefüllt wurden, falls nicht, wird ein PopUp angezeigt und der Eintrag wird nicht an die Verwaltung übergeben
                        if (textField_startdatum.getText().equals("") || textField_enddatum.getText().equals("") || textField_Beschreibung.getText().equals("") || textField_ort.getText().equals("")) {
                            JOptionPane.showMessageDialog(panel_KalendereintragAendern, "Bitte alle Felder ausfüllen!");   }

                        else  {
                                // Fehler Varibale erstellen / 3 -> Initialzustand / 0 -> Kein Fehler / Alles andere -> Fehler

                                int fehler = 3;

                                // 1. StartDatum auslesen, parsen und als Timestamp abspeichern

                                // String mit allen Angaben des Startdatums bauen
                                String volles_Datum_start = textField_startdatum.getText() + " " + comboBox_Tag.getSelectedItem() + ":" + comboBox_Monat.getSelectedItem();
                                String volles_Datum_end = textField_enddatum.getText() + " " + comboBox_Tag2.getSelectedItem() + ":" + comboBox_Monat2.getSelectedItem();

                               // String wird via SimpleDateFormat geparst, da es zu Fehlern kommen kann mit try/catch Block abgefangen
                               SimpleDateFormat start_date = new SimpleDateFormat("dd-MM-yyyy HH:mm");
                               SimpleDateFormat end_date = new SimpleDateFormat("dd-MM-yyyy HH:mm");

                                    try {
                                        start_date_1 = start_date.parse(volles_Datum_start);
                                        end_date_1 = end_date.parse(volles_Datum_end);
                                    } catch (ParseException ex) {
                                        Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                    }

                               // SimpleDateFormat wird in GregorianCalendar konvertiert und daraus dann ein Timestamp erzeugt

                                    Calendar cal_start = Calendar.getInstance();
                                    cal_start.setTime(start_date_1);                    // Startzeitpunkt
                                    cal_start.set(Calendar.MILLISECOND, 0);
                                    Timestamp s = new Timestamp(cal_start.getTimeInMillis());

                                    Calendar cal_ende = Calendar.getInstance();
                                    cal_ende.setTime(end_date_1);                    // Startzeitpunkt
                                    cal_ende.set(Calendar.MILLISECOND, 0);
                                    Timestamp e = new Timestamp(cal_ende.getTimeInMillis());

                                    System.out.println(s + "   " + e);


                            if(chckbxKalendereintrag.isSelected() == true)
                            {
                                // Dann handelt es sich um einen normalen Kalendereintrag, Felder werden ausgelesen und an die Verwaltung übermitteln
                                // Attribute die wir für das Eintragen des Kalenders brauchen:
                                 int kategorie_id = 0;
                                 int kalender_id = 0;
                                 int besitzer_id = 0;
                                 int eintrag_id = 0; 
                                 int erinnerung = 0;
                                 String ort = textField_ort.getText();
                                 String beschreibung = textField_Beschreibung.getText();
                                    try {
                                        kategorie_id = kategorie.get(comboBox_Kategorien.getSelectedItem()).get_kategorie_id();
                                        kalender_id = kalendereintrag.get(comboBox_Eintrag.getSelectedItem()).get_kalender_id();
                                        besitzer_id = kalendereintrag.get(comboBox_Eintrag.getSelectedItem()).get_erstelltvon();
                                        eintrag_id = kalendereintrag.get(comboBox_Eintrag.getSelectedItem()).get_eintrag_id();
                                    } catch (RemoteException ex) {
                                        Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                    }
                                 if(chckbxErinnern.isSelected())
                                     erinnerung = 1;

                                        try {
                                            // O
                                            Kalendereintrag editierter_eintrag = kalendereintrag.get(comboBox_Eintrag.getSelectedItem());
                                            editierter_eintrag.set_beschreibung(beschreibung);
                                            editierter_eintrag.set_ende(e);
                                            editierter_eintrag.set_erinnerung(erinnerung);
                                            editierter_eintrag.set_kategorie(kategorie_id);
                                            editierter_eintrag.set_ort(ort);
                                            editierter_eintrag.set_start(s);

                                            // Kalendereintrag wird an die Verwaltung übergeben, dort geprüft und bei Erfolg in die DB geupdated
                                            v.updateKalendereintrag(editierter_eintrag);
                                            fehler = 0;
                                        } catch (RemoteException ex) {
                                           JOptionPane.showMessageDialog(panel_KalendereintragAendern, ex.getCause().toString().substring(26));
                                           fehler = 1;
                                        }
                                 if (fehler == 0) {
                                    JOptionPane.showMessageDialog(panel_KalendereintragAendern, "Kalendereintrag " + beschreibung + " erfolgreich editiert.");
                                    zeichnePanelUebersicht();
                                 }

                            }
                            else if(chckbxWiederholung.isSelected() == true )
                            {
                                // Dann handelt es sich um einen normalen Kalendereintrag, Felder werden ausgelesen und an die Verwaltung übermitteln
                                // Attribute die wir für das Eintragen des Kalenders brauchen:
                                 int kategorie_id = 0;
                                 int kalender_id = 0;
                                 int besitzer_id = 0;
                                 int eintrag_id = 0;
                                 int erinnerung = 0;
                                 String ort = textField_ort.getText();
                                 String beschreibung = textField_Beschreibung.getText();
                                 char serienmuster;

                                 // Serienmuster auslesen
                                 if(comboBox_WiederholArt.getSelectedItem().equals("täglich"))
                                     serienmuster = 't';
                                 else if(comboBox_WiederholArt.getSelectedItem().equals("wöchentlich"))
                                     serienmuster = 'w';
                                 else if(comboBox_WiederholArt.getSelectedItem().equals("monatlich"))
                                     serienmuster = 'm';
                                 else
                                     serienmuster = 'y';

                                    try {
                                        kategorie_id = kategorie.get(comboBox_Kategorien.getSelectedItem()).get_kategorie_id();
                                        kalender_id = wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_kalender_id();
                                        besitzer_id = wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_erstelltvon();
                                        eintrag_id = wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_eintrag_id();
                                    } catch (RemoteException ex) {
                                        Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                    }
                                 if(chckbxErinnern.isSelected())
                                     erinnerung = 1;

                                        try {
                                            // O
                                            Wiederholung editierter_eintrag = wiederholungen.get(comboBox_Eintrag.getSelectedItem());
                                            editierter_eintrag.set_beschreibung(beschreibung);
                                            editierter_eintrag.set_ende(e);
                                            editierter_eintrag.set_erinnerung(erinnerung);
                                            editierter_eintrag.set_kategorie(kategorie_id);
                                            editierter_eintrag.set_ort(ort);
                                            editierter_eintrag.set_start(s);
                                            editierter_eintrag.set_serienmuster(serienmuster);
                                            editierter_eintrag.set_anzahl(Integer.parseInt(anzahl_wiederholung.getSelectedItem().toString()));

                                            // Kalendereintrag wird an die Verwaltung übergeben, dort geprüft und bei Erfolg in die DB geupdated
                                            v.updateWiederholung(editierter_eintrag);
                                            fehler = 0;
                                        } catch (RemoteException ex) {
                                           JOptionPane.showMessageDialog(panel_KalendereintragAendern, ex.getCause().toString().substring(26));
                                           fehler = 1;
                                        }
                                 if (fehler == 0) {
                                    JOptionPane.showMessageDialog(panel_KalendereintragAendern, "Wiederholung " + beschreibung + " erfolgreich editiert.");
                                    zeichnePanelUebersicht();
                                 }

                            }
                            else if(chckbxTermine.isSelected() == true)
                            {
                                // Dann handelt es sich um einen Termin, Felder werden ausgelesen und an die Verwaltung übermitteln
                                // Attribute die wir für das Eintragen des Termins brauchen:
                                 int kategorie_id = 0;
                                 int erinnerung = 0;
                                 String ort = textField_ort.getText();
                                 String beschreibung = textField_Beschreibung.getText();
                                    try {
                                        kategorie_id = kategorie.get(comboBox_Kategorien.getSelectedItem()).get_kategorie_id();
                                    } catch (RemoteException ex) {
                                        Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                    }
                                 if(chckbxErinnern.isSelected())
                                     erinnerung = 1;

                                 // Der Vector mit den eingeladenen Personen wird erstellt
                                 Vector <Person> teilnehmer_vector = new Vector<Person>();

                                 // Es werden alle Personen ausgelesen und einen zusätzlichen Vector geschrieben
                                 int anzahl_personen = 0;
                                            try {
                                                anzahl_personen = v.getAllPerson_ohne_uebergebene_person(eingeloggte_person).size();
                                            } catch (RemoteException ex) {
                                                Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                            }

                                 // Nun wird überprüft welche Teilnehmer angeklickt wurden, diese werden dem Vector hinzugefügt
                                 for(int i=0; i< anzahl_personen; i++ )
                                   {
                                       int person_id = 0;
                                            try {
                                                //Wir lesen die Person_ID aus
                                                Person x = v.getAllPerson_ohne_uebergebene_person(eingeloggte_person).elementAt(i);
                                                person_id = x.get_person_id();
                                            } catch (RemoteException ex) {
                                                Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                            }

                                        if(teilnehmer_checkbox[i].isSelected()){
                                            try {
                                                teilnehmer_vector.add(v.getPerson_byid(person_id));
                                            } catch (RemoteException ex) {
                                                Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                            }
                                       }

                                       else {
                                            try {
                                                System.out.println("Person " + v.getPerson_byid(person_id).get_voller_name() + " bekommt keine Einladung");
                                            } catch (RemoteException ex) {
                                                Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                            }
                                       }


                                        }

                                        try {
                                            // Nun liegen alle Eingaben vor, das Termin Objekt wird mit den Eingaben geupdatet und dann an die Verwaltung übergeben
                                            Termin editierter_eintrag = termine.get(comboBox_Eintrag.getSelectedItem());
                                            editierter_eintrag.set_beschreibung(beschreibung);
                                            editierter_eintrag.set_ende(e);
                                            editierter_eintrag.set_erinnerung(erinnerung);
                                            editierter_eintrag.set_kategorie(kategorie_id);
                                            editierter_eintrag.set_ort(ort);
                                            editierter_eintrag.set_start(s);
                                            editierter_eintrag.set_eingeladene_personen(teilnehmer_vector);

                                            // Kalendereintrag wird an die Verwaltung übergeben, dort geprüft und bei Erfolg in die DB geupdated
                                            v.updateTermin(editierter_eintrag);
                                            fehler = 0;
                                        } catch (RemoteException ex) {
                                           JOptionPane.showMessageDialog(panel_KalendereintragAendern, ex.getCause().toString().substring(26));
                                           fehler = 1;
                                        }
                                 if (fehler == 0) {
                                    JOptionPane.showMessageDialog(panel_KalendereintragAendern, "Termin " + beschreibung + " erfolgreich editiert.");
                                    zeichnePanelUebersicht();
                                 }

                            }
                            else if(chckbxTerminWiederholung.isSelected() == true)
                            {
                                // Dann handelt es sich um einen normalen Kalendereintrag, Felder werden ausgelesen und an die Verwaltung übermitteln
                                // Attribute die wir für das Eintragen des Kalenders brauchen:
                                 int kategorie_id = 0;                                 
                                 int besitzer_id = 0;
                                 int eintrag_id = 0;
                                 int erinnerung = 0;
                                 String ort = textField_ort.getText();
                                 String beschreibung = textField_Beschreibung.getText();
                                 char serienmuster;

                                 // Der Vector mit den eingeladenen Personen wird erstellt
                                 Vector <Person> teilnehmer_vector = new Vector<Person>();

                                 // Es werden alle Personen ausgelesen und einen zusätzlichen Vector geschrieben
                                 int anzahl_personen = 0;
                                            try {
                                                anzahl_personen = v.getAllPerson_ohne_uebergebene_person(eingeloggte_person).size();
                                            } catch (RemoteException ex) {
                                                Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                            }

                                 // Nun wird überprüft welche Teilnehmer angeklickt wurden, diese werden dem Vector hinzugefügt
                                 for(int i=0; i< anzahl_personen; i++ )
                                   {
                                       int person_id = 0;
                                            try {
                                                //Wir lesen die Person_ID aus
                                                Person x = v.getAllPerson_ohne_uebergebene_person(eingeloggte_person).elementAt(i);
                                                person_id = x.get_person_id();
                                            } catch (RemoteException ex) {
                                                Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                            }

                                        if(teilnehmer_checkbox[i].isSelected()){
                                            try {
                                                teilnehmer_vector.add(v.getPerson_byid(person_id));
                                            } catch (RemoteException ex) {
                                                Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                            }
                                       }

                                       else {
                                            try {
                                                System.out.println("Person " + v.getPerson_byid(person_id).get_voller_name() + " bekommt keine Einladung");
                                            } catch (RemoteException ex) {
                                                Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                            }
                                       }

                                 // Serienmuster auslesen
                                 if(comboBox_WiederholArt.getSelectedItem().equals("täglich"))
                                     serienmuster = 't';
                                 else if(comboBox_WiederholArt.getSelectedItem().equals("wöchentlich"))
                                     serienmuster = 'w';
                                 else if(comboBox_WiederholArt.getSelectedItem().equals("monatlich"))
                                     serienmuster = 'm';
                                 else
                                     serienmuster = 'y';

                                    try {
                                        kategorie_id = kategorie.get(comboBox_Kategorien.getSelectedItem()).get_kategorie_id();
                                        besitzer_id = termin_wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_erstelltvon();
                                        eintrag_id = termin_wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_eintrag_id();
                                    } catch (RemoteException ex) {
                                        Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                    }
                                 if(chckbxErinnern.isSelected())
                                     erinnerung = 1;

                                        try {
                                            // O
                                            Termin editierter_eintrag = termin_wiederholungen.get(comboBox_Eintrag.getSelectedItem());
                                            editierter_eintrag.set_beschreibung(beschreibung);
                                            editierter_eintrag.set_ende(e);
                                            editierter_eintrag.set_erinnerung(erinnerung);
                                            editierter_eintrag.set_kategorie(kategorie_id);
                                            editierter_eintrag.set_ort(ort);
                                            editierter_eintrag.set_start(s);
                                            editierter_eintrag.set_serienmuster(serienmuster);
                                            editierter_eintrag.set_anzahl(Integer.parseInt(anzahl_wiederholung.getSelectedItem().toString()));
                                            editierter_eintrag.set_eingeladene_personen(teilnehmer_vector);
                                           
                                            System.out.println("HIER KOMMT DIE KALENDERID:");
                                            System.out.println("-------------------------");
                                            System.out.println(editierter_eintrag.get_kalender_id());
                                            

                                            // Kalendereintrag wird an die Verwaltung übergeben, dort geprüft und bei Erfolg in die DB geupdated
                                            v.updateTermin_wiederholung(editierter_eintrag);
                                            fehler = 0;
                                        } catch (RemoteException ex) {
                                           JOptionPane.showMessageDialog(panel_KalendereintragAendern, ex.getCause().toString().substring(26));
                                           fehler = 1;
                                        }
                                 if (fehler == 0) {
                                    JOptionPane.showMessageDialog(panel_KalendereintragAendern, "Wiederholung " + beschreibung + " erfolgreich editiert.");
                                    zeichnePanelUebersicht();
                                 }

                            }
                           }

                        }
                     }
                });
                button_Erstellen.setBounds(50, 490, 90, 20);
                panel_KalendereintragAendern.add(button_Erstellen);

                panel_KalendereintragAendern.setVisible(true);
        }

        private void zeichnePanelKalendereintragLoeschen()
        {
                versteckePanels();



                // Wir initialisieren die für die Auslesefunktion wichtigen Vectoren und Hashmaps
                unsere_kategorien = new Vector();
                unsere_kalendereintraege = new Vector();
                unsere_wiederholungen = new Vector();
                unsere_termine = new Vector();
                unsere_termin_wiederholung = new Vector();
                //kalendereintrag = new HashMap<String, Kalendereintrag>();

                // Wir lesen alle Kategorien, Kalendereinträge aus und schreiben diese in einen neuen Vektor
                 try {
                     // Wir lesen alle Kategorien aus
                     v = getVerwaltung();
                     unsere_kategorien = v.get_all_Kategorie();
                     unsere_kalendereintraege = v.get_kalendereintraege_by_person(eingeloggte_person);
                     unsere_wiederholungen = v.get_wiederholungen_by_person(eingeloggte_person);
                     unsere_termine = v.get_termine_by_person(eingeloggte_person);
                     unsere_personen = v.getAllPerson_ohne_uebergebene_person(eingeloggte_person);
                     unsere_termin_wiederholung = v.get_wiederholung_termine_by_person(eingeloggte_person);

                 } catch (RemoteException re) {

                 }

                //Hashmap für die ComboBox der Kateogiren wird erstellt
                kategorie = new HashMap<String, Kategorie>();
                for (int i = 0; i < unsere_kategorien.size(); i++) {
                    try {
                        kategorie.put(unsere_kategorien.elementAt(i).get_name(), unsere_kategorien.elementAt(i));
                    } catch (RemoteException ex) {
                    }
                }



                panel_Hintergrund.removeAll();



                panel_KalendereintragAendern = new JPanel();
                panel_Hintergrund.add(panel_KalendereintragAendern, BorderLayout.CENTER);
                panel_KalendereintragAendern.setLayout(null);

                label_filter = new JLabel("Filter wählen:");
                label_filter.setBounds(50, 75, 100, 20);
                panel_KalendereintragAendern.add(label_filter);

                chckbxKalendereintrag = new JCheckBox("Kalendereinträge");
                chckbxKalendereintrag.setBounds(210, 65, 150, 40);
                chckbxKalendereintrag.setSelected(false);
                chckbxKalendereintrag.addItemListener (new ItemListener() {
                        public void itemStateChanged(ItemEvent e) {
                            initKalendereintrag();
                        }
                });
                panel_KalendereintragAendern.add(chckbxKalendereintrag);

                chckbxWiederholung = new JCheckBox("Wiederholung");
                chckbxWiederholung.setBounds(360, 65, 150, 40);
                chckbxWiederholung.setSelected(false);
                chckbxWiederholung.addItemListener(new ItemListener() {
                        public void itemStateChanged(ItemEvent e) {
                            initWiederholungeintrag();
                        }
                });
                panel_KalendereintragAendern.add(chckbxWiederholung);

                chckbxTermine = new JCheckBox("Termine");
                chckbxTermine.setBounds(510, 65, 100, 40);
                chckbxTermine.setSelected(false);
                chckbxTermine.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                            initTermin();
                        }
                });
                panel_KalendereintragAendern.add(chckbxTermine);

                chckbxTerminWiederholung = new JCheckBox("Termin mit Wiederholung");
                chckbxTerminWiederholung.setBounds(610, 65, 170, 40);
                chckbxTerminWiederholung.setSelected(false);
                chckbxTerminWiederholung.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                            initTerminWiederholung();

                        }
                });
                panel_KalendereintragAendern.add(chckbxTerminWiederholung);


                ButtonGroup filter = new ButtonGroup();
                filter.add(chckbxKalendereintrag);
                filter.add(chckbxWiederholung);
                filter.add(chckbxTerminWiederholung);
                filter.add(chckbxTermine);

                JLabel label_KalendereintragErstellen = new JLabel("Eintrag löschen");
                label_KalendereintragErstellen.setFont(new Font("Tahoma", Font.PLAIN, 15));
                label_KalendereintragErstellen.setBounds(50, 30, 220, 30);
                panel_KalendereintragAendern.add(label_KalendereintragErstellen);

                JLabel label_Kalenderwahl = new JLabel("Kalenderbezeichnung:");
                label_Kalenderwahl.setBounds(50, 110, 150, 20);
                panel_KalendereintragAendern.add(label_Kalenderwahl);

                JLabel label_Besitzer = new JLabel("Beschreibung / Ort:");
                label_Besitzer.setBounds(50, 130, 150, 20);
                panel_KalendereintragAendern.add(label_Besitzer);

                comboBox_Eintrag = new JComboBox();
                comboBox_Eintrag.setBounds(210, 110, 400, 40);
                comboBox_Eintrag.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                            if(comboBox_Eintrag.getItemCount() != 0) //Abfangen von leerer ComboBoxen -> nach dem removeallitems
                            {
                            if(chckbxKalendereintrag.isSelected())
                            {
                                try {
                                // Ausblenden der nicht benötigten Elemente und setzen der Defaultwerte
                                anzahl_wiederholung.setVisible(false);
                                comboBox_WiederholArt.setVisible(false);
                                label_anzahl_wiederholung.setVisible(false);
                                chckbxErinnern.setSelected(false);
                                chckbxTermin.setSelected(false);
                                button_teilnehmer_hinzufuegen.setVisible(false);

                                // Wir holen den ausgewählten Kalendereintrag
                                textField_Beschreibung.setText(kalendereintrag.get(comboBox_Eintrag.getSelectedItem()).get_beschreibung());
                                textField_Beschreibung.updateUI();
                                textField_ort.setText(kalendereintrag.get(comboBox_Eintrag.getSelectedItem()).get_ort());
                                textField_ort.updateUI();

                                //Setzen des Datums
                                String s = new SimpleDateFormat("dd-MM-yyyy").format(kalendereintrag.get(comboBox_Eintrag.getSelectedItem()).get_start());
                                textField_startdatum.setText(s);
                                s = new SimpleDateFormat("dd-MM-yyyy").format(kalendereintrag.get(comboBox_Eintrag.getSelectedItem()).get_ende());
                                textField_enddatum.setText(s);

                                //Setzen der Uhrzeit
                                s = new SimpleDateFormat("HH").format(kalendereintrag.get(comboBox_Eintrag.getSelectedItem()).get_start());
                                comboBox_Tag.setSelectedItem(s);
                                s = new SimpleDateFormat("mm").format(kalendereintrag.get(comboBox_Eintrag.getSelectedItem()).get_start());
                                comboBox_Monat.setSelectedItem(s);
                                s = new SimpleDateFormat("HH").format(kalendereintrag.get(comboBox_Eintrag.getSelectedItem()).get_ende());
                                comboBox_Tag2.setSelectedItem(s);
                                s = new SimpleDateFormat("mm").format(kalendereintrag.get(comboBox_Eintrag.getSelectedItem()).get_ende());
                                comboBox_Monat2.setSelectedItem(s);

                                // Checkbox Erinnerung auslesen
                                if(kalendereintrag.get(comboBox_Eintrag.getSelectedItem()).get_erinnerung() == 1)
                                    chckbxErinnern.setSelected(true);
                                else
                                    chckbxErinnern.setSelected(false);


                            } catch (RemoteException ex) {
                                Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                            }
                            }
                            if(chckbxWiederholung.isSelected())
                            {
                                try {

                                // Ausblenden der nicht benötigten Elemente und setzen der Defaultwerte
                                anzahl_wiederholung.setVisible(true);
                                comboBox_WiederholArt.setVisible(true);
                                label_anzahl_wiederholung.setVisible(true);
                                chckbxErinnern.setSelected(false);
                                chckbxTermin.setSelected(false);
                                button_teilnehmer_hinzufuegen.setVisible(false);

                                // Wir holen die ausgewählte Wiederholung
                                textField_Beschreibung.setText(wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_beschreibung());
                                textField_ort.setText(wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_ort());

                                //Setzen des Datums
                                String s = new SimpleDateFormat("dd-MM-yyyy").format(wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_start());
                                textField_startdatum.setText(s);
                                s = new SimpleDateFormat("dd-MM-yyyy").format(wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_ende());
                                textField_enddatum.setText(s);

                                //Setzen der Uhrzeit
                                s = new SimpleDateFormat("HH").format(wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_start());
                                comboBox_Tag.setSelectedItem(s);
                                s = new SimpleDateFormat("mm").format(wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_start());
                                comboBox_Monat.setSelectedItem(s);
                                s = new SimpleDateFormat("HH").format(wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_ende());
                                comboBox_Tag2.setSelectedItem(s);
                                s = new SimpleDateFormat("mm").format(wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_ende());
                                comboBox_Monat2.setSelectedItem(s);

                                // Checkbox Erinnerung auslesen
                                if(wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_erinnerung() == 1)
                                    chckbxErinnern.setSelected(true);
                                else
                                    chckbxErinnern.setSelected(false);

                                // Wiederholung Checkbox wird gesetzt
                                chckbxWiederholen.setSelected(true);

                                // Anzahl der Tage auslesen und setzen
                                anzahl_wiederholung.setSelectedItem(wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_anzahl());


                                // Auslesen der ComboBox Wiederholung und setzen des Chars
                                 if(wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_serienmuster() == 't')
                                     comboBox_WiederholArt.setSelectedItem("täglich");
                                 else if(wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_serienmuster() == 'w')
                                     comboBox_WiederholArt.setSelectedItem("wöchentlich");
                                 else if(wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_serienmuster() == 'm')
                                     comboBox_WiederholArt.setSelectedItem("monatlich");
                                 else
                                     comboBox_WiederholArt.setSelectedItem("jährlich");

                                // Checkbox Erinnerung auslesen
                                if(wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_erinnerung() == 1)
                                    chckbxErinnern.setSelected(true);
                                else
                                    chckbxErinnern.setSelected(false);

                            } catch (RemoteException ex) {
                                Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                            }
                            }
                            if(chckbxTermine.isSelected())
                            {
                                try {
                                // Ausblenden der nicht benötigten Elemente und setzen der Defaultwerte
                                anzahl_wiederholung.setVisible(false);
                                comboBox_WiederholArt.setVisible(false);
                                label_anzahl_wiederholung.setVisible(false);
                                chckbxTermin.setSelected(true);
                                button_teilnehmer_hinzufuegen.setVisible(true);

                                // Wir holen den ausgewählten Kalendereintrag
                                textField_Beschreibung.setText(termine.get(comboBox_Eintrag.getSelectedItem()).get_beschreibung());
                                textField_Beschreibung.updateUI();
                                textField_ort.setText(termine.get(comboBox_Eintrag.getSelectedItem()).get_ort());
                                textField_ort.updateUI();

                                //Setzen des Datums
                                String s = new SimpleDateFormat("dd-MM-yyyy").format(termine.get(comboBox_Eintrag.getSelectedItem()).get_start());
                                textField_startdatum.setText(s);
                                s = new SimpleDateFormat("dd-MM-yyyy").format(termine.get(comboBox_Eintrag.getSelectedItem()).get_ende());
                                textField_enddatum.setText(s);

                                //Setzen der Uhrzeit
                                s = new SimpleDateFormat("HH").format(termine.get(comboBox_Eintrag.getSelectedItem()).get_start());
                                comboBox_Tag.setSelectedItem(s);
                                s = new SimpleDateFormat("mm").format(termine.get(comboBox_Eintrag.getSelectedItem()).get_start());
                                comboBox_Monat.setSelectedItem(s);
                                s = new SimpleDateFormat("HH").format(termine.get(comboBox_Eintrag.getSelectedItem()).get_ende());
                                comboBox_Tag2.setSelectedItem(s);
                                s = new SimpleDateFormat("mm").format(termine.get(comboBox_Eintrag.getSelectedItem()).get_ende());
                                comboBox_Monat2.setSelectedItem(s);

                                // Checkbox Erinnerung auslesen
                                if(termine.get(comboBox_Eintrag.getSelectedItem()).get_erinnerung() == 1)
                                    chckbxErinnern.setSelected(true);
                                else
                                    chckbxErinnern.setSelected(false);


                            } catch (RemoteException ex) {
                                Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                            }
                            }
                            if(chckbxTerminWiederholung.isSelected())
                            {
                                try {

                                // Ausblenden der nicht benötigten Elemente und setzen der Defaultwerte
                                anzahl_wiederholung.setVisible(true);
                                comboBox_WiederholArt.setVisible(true);
                                label_anzahl_wiederholung.setVisible(true);
                                chckbxErinnern.setSelected(false);
                                chckbxTermin.setSelected(true);
                                button_teilnehmer_hinzufuegen.setVisible(true);

                                // Wir holen die ausgewählte Wiederholung
                                textField_Beschreibung.setText(termin_wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_beschreibung());
                                textField_ort.setText(termin_wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_ort());

                                //Setzen des Datums
                                String s = new SimpleDateFormat("dd-MM-yyyy").format(termin_wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_start());
                                textField_startdatum.setText(s);
                                s = new SimpleDateFormat("dd-MM-yyyy").format(termin_wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_ende());
                                textField_enddatum.setText(s);

                                //Setzen der Uhrzeit
                                s = new SimpleDateFormat("HH").format(termin_wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_start());
                                comboBox_Tag.setSelectedItem(s);
                                s = new SimpleDateFormat("mm").format(termin_wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_start());
                                comboBox_Monat.setSelectedItem(s);
                                s = new SimpleDateFormat("HH").format(termin_wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_ende());
                                comboBox_Tag2.setSelectedItem(s);
                                s = new SimpleDateFormat("mm").format(termin_wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_ende());
                                comboBox_Monat2.setSelectedItem(s);

                                // Checkbox Erinnerung auslesen
                                if(termin_wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_erinnerung() == 1)
                                    chckbxErinnern.setSelected(true);
                                else
                                    chckbxErinnern.setSelected(false);

                                // Wiederholung Checkbox wird gesetzt
                                chckbxWiederholen.setSelected(true);

                                // Anzahl der Tage auslesen und setzen
                                anzahl_wiederholung.setSelectedItem(termin_wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_anzahl());


                                // Auslesen der ComboBox Wiederholung und setzen des Chars
                                 if(termin_wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_serienmuster() == 't')
                                     comboBox_WiederholArt.setSelectedItem("täglich");
                                 else if(termin_wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_serienmuster() == 'w')
                                     comboBox_WiederholArt.setSelectedItem("wöchentlich");
                                 else if(termin_wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_serienmuster() == 'm')
                                     comboBox_WiederholArt.setSelectedItem("monatlich");
                                 else
                                     comboBox_WiederholArt.setSelectedItem("jährlich");

                                // Checkbox Erinnerung auslesen
                                if(termin_wiederholungen.get(comboBox_Eintrag.getSelectedItem()).get_erinnerung() == 1)
                                    chckbxErinnern.setSelected(true);
                                else
                                    chckbxErinnern.setSelected(false);

                            } catch (RemoteException ex) {
                                Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                            }
                            }
                            }

                        }
                });
                panel_KalendereintragAendern.add(comboBox_Eintrag);



                JLabel label_Datum = new JLabel("Startdatum auswählen:");
                label_Datum.setBounds(50, 165, 170, 30);
                panel_KalendereintragAendern.add(label_Datum);

                textField_startdatum = new JTextField();
                textField_startdatum.enableInputMethods(true);
                textField_startdatum.setEditable(false);
                textField_startdatum.setBounds(210, 170, 80, 20);
                panel_KalendereintragAendern.add(textField_startdatum);

                final JFrame f = new JFrame();

                f.setTitle("Startdatum auswählen");

                f.pack();
                f.setVisible(false);



                JLabel label_startuhrzeit = new JLabel("Startzeit wählen:");
                label_startuhrzeit.setBounds(450, 165, 170, 30);
                panel_KalendereintragAendern.add(label_startuhrzeit);



                comboBox_Tag = new JComboBox();
                comboBox_Tag.setEditable(false);
                comboBox_Tag.setEnabled(false);
                comboBox_Tag.setBounds(560, 170, 50, 20);
                panel_KalendereintragAendern.add(comboBox_Tag);
                for(int i=0; i<24; i++)
                {
                    // Für 2 stellige Ausgabe in der ComboBox, wichtig auch zum parsen des Datums z.B. 1 -> 01
                    String zahl = String.format("%02d", i);
                    comboBox_Tag.addItem(zahl);
                }


                comboBox_Monat = new JComboBox();
                comboBox_Monat.setBounds(620, 170, 50, 20);
                comboBox_Monat.setEditable(false);
                comboBox_Monat.setEnabled(false);
                panel_KalendereintragAendern.add(comboBox_Monat);

                for(int i=0; i<60; i++)
                {
                     // Für 2 stellige Ausgabe in der ComboBox, wichtig auch zum parsen des Datums z.B. 1 -> 01
                    String zahl = String.format("%02d", i);
                    comboBox_Monat.addItem(zahl);
                }


                label_Enddatum = new JLabel("Enddatum auswählen:");
                label_Enddatum.setBounds(50, 200, 170, 30);
                panel_KalendereintragAendern.add(label_Enddatum);

                textField_enddatum = new JTextField();
                textField_enddatum.enableInputMethods(true);
                textField_enddatum.setEditable(false);
                textField_enddatum.setBounds(210, 200, 80, 20);
                panel_KalendereintragAendern.add(textField_enddatum);

                final JFrame f2 = new JFrame();

                f2.setTitle("Startdatum auswählen");

                f2.pack();
                f2.setVisible(false);

                label_enduhrzeit = new JLabel("Endzeit wählen:");
                label_enduhrzeit.setBounds(450, 195, 170, 30);
                panel_KalendereintragAendern.add(label_enduhrzeit);



                comboBox_Tag2 = new JComboBox();
                comboBox_Tag2.setEditable(false);
                comboBox_Tag2.setEnabled(false);
                comboBox_Tag2.setBounds(560, 200, 50, 20);
                panel_KalendereintragAendern.add(comboBox_Tag2);
                for(int i=0; i<=23; i++)
                {
                     // Für 2 stellige Ausgabe in der ComboBox, wichtig auch zum parsen des Datums z.B. 1 -> 01
                    String zahl = String.format("%02d", i);
                    comboBox_Tag2.addItem(zahl);
                }


                comboBox_Monat2 = new JComboBox();
                comboBox_Monat2.setEditable(false);
                comboBox_Monat2.setEnabled(false);
                comboBox_Monat2.setBounds(620, 200, 50, 20);
                panel_KalendereintragAendern.add(comboBox_Monat2);

                for(int i=0; i<=59; i++)
                {
                     // Für 2 stellige Ausgabe in der ComboBox, wichtig auch zum parsen des Datums z.B. 1 -> 01
                    String zahl = String.format("%02d", i);
                    comboBox_Monat2.addItem(zahl);
                }



                label_Beschreibung = new JLabel("Beschreibung:");
                label_Beschreibung.setBounds(50, 260, 150, 20);
                panel_KalendereintragAendern.add(label_Beschreibung);

                textField_Beschreibung = new JTextField();
                textField_Beschreibung.setEditable(false);
                textField_Beschreibung.setBounds(210, 260, 400, 20);
                panel_KalendereintragAendern.add(textField_Beschreibung);

                label_Kategorien = new JLabel("Kategorie:");
                label_Kategorien.setBounds(50, 300, 70, 20);
                panel_KalendereintragAendern.add(label_Kategorien);

                comboBox_Kategorien = new JComboBox();
                comboBox_Kategorien.setEnabled(false);
                comboBox_Kategorien.setEditable(false);
                comboBox_Kategorien.setBounds(210, 300, 230, 20);
                panel_KalendereintragAendern.add(comboBox_Kategorien);

                label_ort = new JLabel("Ort:");
                label_ort.setBounds(50, 330, 70, 20);
                panel_KalendereintragAendern.add(label_ort);

                textField_ort = new JTextField();
                textField_ort.setEditable(false);
                textField_ort.setBounds(210, 330, 400, 20);
                panel_KalendereintragAendern.add(textField_ort);

                // Wir befüllen die ComboBox mit den Einträgen der HashMap kalender
                for (String key : kategorie.keySet()) {
                    comboBox_Kategorien.addItem(key);
                }


                comboBox_WiederholArt = new JComboBox();
                comboBox_WiederholArt.setBounds(210, 360, 150, 20);
                comboBox_WiederholArt.setVisible(false);
                comboBox_WiederholArt.addItem(new String("täglich"));
                comboBox_WiederholArt.addItem(new String("wöchentlich"));
                comboBox_WiederholArt.addItem(new String("monatlich"));
                comboBox_WiederholArt.addItem(new String("jährlich"));
                comboBox_WiederholArt.setEditable(false);
                comboBox_WiederholArt.setEnabled(false);

                label_anzahl_wiederholung = new JLabel("Anzahl der Wiederholung:");
                label_anzahl_wiederholung.setBounds(400, 360, 170, 20);
                label_anzahl_wiederholung.setVisible(false);
                panel_KalendereintragAendern.add(label_anzahl_wiederholung);

                anzahl_wiederholung = new JComboBox();
                anzahl_wiederholung.setEditable(false);
                anzahl_wiederholung.setEnabled(false);
                anzahl_wiederholung.setBounds(560, 360, 50, 20);
                anzahl_wiederholung.setVisible(false);
                panel_KalendereintragAendern.add(anzahl_wiederholung);
                for(int i=0; i<=10; i++)
                {
                     // Für 2 stellige Ausgabe in der ComboBox, wichtig auch zum parsen des Datums z.B. 1 -> 01

                    anzahl_wiederholung.addItem(i);
                }

                panel_KalendereintragAendern.add(comboBox_WiederholArt);

                chckbxWiederholen = new JCheckBox("Wiederholen?");
                chckbxWiederholen.setBounds(50, 360, 150, 20);
                chckbxWiederholen.setSelected(false);
                chckbxWiederholen.setEnabled(false);
                chckbxWiederholen.addItemListener(new ItemListener() {
                        public void itemStateChanged(ItemEvent arg0) {
                                comboBox_WiederholArt.setVisible(chckbxWiederholen.isSelected());
                                anzahl_wiederholung.setVisible(chckbxWiederholen.isSelected());
                                label_anzahl_wiederholung.setVisible(chckbxWiederholen.isSelected());
                        }
                });
                panel_KalendereintragAendern.add(chckbxWiederholen);

                chckbxTermin = new JCheckBox("<html>Teilnehmer<br>hinzufügen?</html>");
                chckbxTermin.setBounds(50, 390, 100, 40);
                chckbxTermin.setSelected(false);
                chckbxTermin.setEnabled(false);
                chckbxTermin.addItemListener(new ItemListener() {
                        public void itemStateChanged(ItemEvent arg0) {
                                button_teilnehmer_hinzufuegen.setVisible(chckbxTermin.isSelected());
                        }
                });
                panel_KalendereintragAendern.add(chckbxTermin);

                button_teilnehmer_hinzufuegen = new JButton("Teilnehmer festlegen");
                button_teilnehmer_hinzufuegen.setVisible(false);
                button_teilnehmer_hinzufuegen.setEnabled(false);
                button_teilnehmer_hinzufuegen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent arg0) {

                        // Wenn der Button gedrückt wird, geht ein neues Fenster, in dem wir die Personen die wir Einladen können festlegen
                        final JFrame teilnehmer_hinzufuegen = new JFrame();

                        teilnehmer_hinzufuegen.setTitle("Teilnehmer wählen");

                        teilnehmer_hinzufuegen.setVisible(true);
                        teilnehmer_hinzufuegen.setBounds(200, 200, 220, 400);
                        teilnehmer_hinzufuegen.setResizable(false);

                        panel_teilnehmer_hinzufuegen = new JPanel();
                        panel_teilnehmer_hinzufuegen.setLayout(null);

                        teilnehmer_hinzufuegen.add(panel_teilnehmer_hinzufuegen);

                        // Wir erstellen unsere CheckBoxen + Personen
                        int y_position = 20;
                        int attempts = unsere_personen.size();
                        teilnehmer_label = new JLabel[attempts];
                        teilnehmer_checkbox = new JCheckBox[attempts];


                        for(int i=0; i< unsere_personen.size(); i++ )
                        {
                            try {

                                teilnehmer_label[i] = new JLabel(unsere_personen.elementAt(i).get_voller_name());
                                teilnehmer_label[i].setBounds(20, y_position, 180, 20);
                                teilnehmer_label[i].setVisible(true);
                                panel_teilnehmer_hinzufuegen.add(teilnehmer_label[i]);

                                teilnehmer_checkbox[i] = new JCheckBox("", false);
                                teilnehmer_checkbox[i].setBounds(150, y_position, 20, 20);
                                teilnehmer_checkbox[i].setVisible(true);
                                panel_teilnehmer_hinzufuegen.add(teilnehmer_checkbox[i]);


                                y_position = y_position + 30;

                            } catch (RemoteException ex) {
                                Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                            }

                        }

                        button_teilnehmer_bestaetigen = new JButton("Speichern");
                        button_teilnehmer_bestaetigen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                            teilnehmer_hinzufuegen.setVisible(false);
                        }
                        });
                        button_teilnehmer_bestaetigen.setBounds(20, y_position, 120, 20);
                        panel_teilnehmer_hinzufuegen.add(button_teilnehmer_bestaetigen);


                        }
                });
                button_teilnehmer_hinzufuegen.setBounds(210, 395, 200, 20);
                panel_KalendereintragAendern.add(button_teilnehmer_hinzufuegen);

                chckbxErinnern = new JCheckBox("Erinnerung");
                chckbxErinnern.setBounds(50, 440, 100, 40);
                chckbxErinnern.setSelected(false);
                chckbxErinnern.setEnabled(false);
                panel_KalendereintragAendern.add(chckbxErinnern);


                button_Abbrechen = new JButton("Abbrechen");
                button_Abbrechen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                            zeichnePanelUebersicht();
                        }
                });
                button_Abbrechen.setBounds(210, 490, 120, 20);
                panel_KalendereintragAendern.add(button_Abbrechen);

                button_Erstellen = new JButton("Löschen");
                button_Erstellen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent arg0) {
                        

                            if(chckbxKalendereintrag.isSelected() == true)
                            {                              
                                   try {
                                            // Kalendereintrag wird an die Verwaltung übergeben, dort wird dieser, samt allen Teilnahmen gelöscht
                                            v.deleteKalendereintrag(kalendereintrag.get(comboBox_Eintrag.getSelectedItem()));
                                            JOptionPane.showMessageDialog(panel_KalendereintragAendern, "Eintrag gelöscht.");
                                            zeichnePanelUebersicht();
                                            
                                        } catch (RemoteException ex) {
                                           JOptionPane.showMessageDialog(panel_KalendereintragAendern, ex.getCause().toString().substring(26));                                         
                                        }

                            }
                            else if(chckbxWiederholung.isSelected() == true )
                            {
                                    try {
                                            // Wiederholung wird an die Verwaltung übergeben, dort wird dieser, samt allen Teilnahmen gelöscht
                                            v.deleteWiederholung(wiederholungen.get(comboBox_Eintrag.getSelectedItem()));
                                            JOptionPane.showMessageDialog(panel_KalendereintragAendern, "Wiederholung gelöscht.");
                                            zeichnePanelUebersicht();

                                        } catch (RemoteException ex) {
                                           JOptionPane.showMessageDialog(panel_KalendereintragAendern, ex.getCause().toString().substring(26));
                                        }
                               

                            }
                            else if(chckbxTermine.isSelected() == true)
                            {
                             try {
                                            // Termin wird an die Verwaltung übergeben, dort wird dieser, samt allen Teilnahmen gelöscht
                                            v.deleteTermin(termine.get(comboBox_Eintrag.getSelectedItem()));
                                            JOptionPane.showMessageDialog(panel_KalendereintragAendern, "Termin samt Teilnehmer gelöscht.");
                                            zeichnePanelUebersicht();

                                        } catch (RemoteException ex) {
                                           JOptionPane.showMessageDialog(panel_KalendereintragAendern, ex.getCause().toString().substring(26));
                                        }

                            }
                            else if(chckbxTerminWiederholung.isSelected() == true)
                            {
                             try {
                                            // Termin wird an die Verwaltung übergeben, dort wird dieser, samt allen Teilnahmen gelöscht
                                            v.deleteTermin_Wiederholung(termin_wiederholungen.get(comboBox_Eintrag.getSelectedItem()));
                                            JOptionPane.showMessageDialog(panel_KalendereintragAendern, "Termin samt Teilnehmer gelöscht.");
                                            zeichnePanelUebersicht();

                                        } catch (RemoteException ex) {
                                           JOptionPane.showMessageDialog(panel_KalendereintragAendern, ex.getCause().toString().substring(26));
                                        }

                            }

                        
                     }
                });
                button_Erstellen.setBounds(50, 490, 90, 20);
                panel_KalendereintragAendern.add(button_Erstellen);

                panel_KalendereintragAendern.setVisible(true);
        }

        private void zeichnePanelPersonAnlegen()
        {
                versteckePanels();

                panel_Hintergrund.removeAll();

                panel_PersonErstellen = new JPanel();
                panel_Hintergrund.add(panel_PersonErstellen, BorderLayout.CENTER);
                panel_PersonErstellen.setLayout(null);

                JLabel label_PersonErstellen = new JLabel("Person erstellen");
                label_PersonErstellen.setFont(new Font("Tahoma", Font.PLAIN, 15));
                label_PersonErstellen.setBounds(50, 30, 220, 30);
                panel_PersonErstellen.add(label_PersonErstellen);

                JLabel label_PersonNachname = new JLabel("Nachname");
                label_PersonNachname.setBounds(50, 80, 90, 20);
                panel_PersonErstellen.add(label_PersonNachname);

                textField_Nachname = new JTextField();
                textField_Nachname.setBounds(210, 80, 200, 20);
                panel_PersonErstellen.add(textField_Nachname);

                JLabel label_PersonVorname = new JLabel("Vorname");
                label_PersonVorname.setBounds(50, 120, 90, 20);
                panel_PersonErstellen.add(label_PersonVorname);

                textField_Vorname = new JTextField();
                textField_Vorname.setBounds(210, 120, 200, 20);
                panel_PersonErstellen.add(textField_Vorname);

                JLabel label_Raum = new JLabel("Raum");
                label_Raum.setBounds(50, 160, 90, 20);
                panel_PersonErstellen.add(label_Raum);

                textField_Raum = new JTextField();
                textField_Raum.setDocument(new IntegerCheck());
                textField_Raum.setBounds(210, 160, 200, 20);
                panel_PersonErstellen.add(textField_Raum);

                JLabel label_TelNr = new JLabel("Telefon");
                label_TelNr.setBounds(50, 200, 90, 20);
                panel_PersonErstellen.add(label_TelNr);

                textField_TelNr = new JTextField();
                textField_TelNr.setDocument(new IntegerCheck());
                textField_TelNr.setBounds(210, 200, 200, 20);
                panel_PersonErstellen.add(textField_TelNr);

                JLabel label_Email = new JLabel("Email");
                label_Email.setBounds(50, 240, 90, 20);
                panel_PersonErstellen.add(label_Email);

                textField_Email = new JTextField();
                textField_Email.setBounds(210, 240, 200, 20);
                panel_PersonErstellen.add(textField_Email);

                button_Abbrechen = new JButton("Abbrechen");
                button_Abbrechen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {

                        }
                });
                button_Abbrechen.setBounds(210, 490, 120, 20);
                panel_PersonErstellen.add(button_Abbrechen);

                button_Erstellen = new JButton("Anlegen");
                button_Erstellen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent arg0) {
                                //Informationen aus Textfeldern ermitteln und in Datenstruktur schreiben
                                 if(textField_Nachname.getText().equals("") || textField_Vorname.getText().equals("") || textField_TelNr.getText().equals("") || textField_Email.getText().equals("") || textField_Raum.getText().equals("") )
                                 JOptionPane.showMessageDialog(panel_PersonErstellen, "Bitte alle Felder ausfüllen!");
                                 else {
                                    try {
                                        v = getVerwaltung();
                                        v.createPerson(1, Integer.parseInt(textField_Raum.getText()), textField_Nachname.getText(), textField_Vorname.getText(), Integer.parseInt(textField_TelNr.getText()), true, textField_Email.getText());
                                        JOptionPane.showMessageDialog(panel_PersonErstellen, "Person angelegt.");
                                        zeichnePanelUebersicht();
                                    } catch (RemoteException ex) {
                                        Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                    }
                                 }
                        }
                });
                button_Erstellen.setBounds(50, 490, 90, 20);
                panel_PersonErstellen.add(button_Erstellen);

                panel_PersonErstellen.setVisible(true);
        }

        private void zeichnePanelPersonAendern()
        {
                versteckePanels();
                Vector <Person> unsere_personen = new Vector();


                // Wir lesen alle Personen aus und schreiben diese in einen neuen Vektor
                 try {
                     // Wir lesen alle Personen aus
                     v = getVerwaltung();
                     unsere_personen = v.getAllPerson();

                 } catch (RemoteException re) {

                 }

                //Hashmap für die ComboBox wird erstellt
                person = new HashMap<String,Person>();
                for (int i = 0; i < unsere_personen.size(); i++) {
                    try {
                        person.put(unsere_personen.elementAt(i).get_voller_name(), unsere_personen.elementAt(i));
                    } catch (RemoteException ex) {
                    }
                }

                panel_Hintergrund.removeAll();

                panel_PersonAendern = new JPanel();
                panel_Hintergrund.add(panel_PersonAendern, BorderLayout.CENTER);
                panel_PersonAendern.setLayout(null);

                JLabel label_PersonBearbeiten = new JLabel("Person bearbeiten");
                label_PersonBearbeiten.setFont(new Font("Tahoma", Font.PLAIN, 15));
                label_PersonBearbeiten.setBounds(50, 30, 220, 30);
                panel_PersonAendern.add(label_PersonBearbeiten);

                JLabel label_PersonWaehlen = new JLabel("Person w\u00E4hlen");
                label_PersonWaehlen.setBounds(50, 80, 130, 20);
                panel_PersonAendern.add(label_PersonWaehlen);

                comboBox_PersonenWahl = new JComboBox(new DefaultComboBoxModel());
                comboBox_PersonenWahl.setBounds(210, 80, 200, 20);
                panel_PersonAendern.add(comboBox_PersonenWahl);

                for (String key : person.keySet()) {
                    comboBox_PersonenWahl.addItem(key);
                }

             
              
                // ActionListener für die ComboBox - Sprich bei jeder Auswahl wird dieser ActionListener ausgeführt und die dementsprechenden JTextField's aktualisiert
                comboBox_PersonenWahl.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {

                        try {
                            Integer t = person.get(comboBox_PersonenWahl.getSelectedItem()).get_telefon();
                            Integer r = person.get(comboBox_PersonenWahl.getSelectedItem()).get_raum();
                            textField_Vorname.setText(person.get(comboBox_PersonenWahl.getSelectedItem()).get_vorname());
                            textField_Nachname.setText(person.get(comboBox_PersonenWahl.getSelectedItem()).get_nachname());
                            textField_TelNr.setText(t.toString());
                            textField_Raum.setText(r.toString());
                            textField_Email.setText(person.get(comboBox_PersonenWahl.getSelectedItem()).get_email());
                        } catch (RemoteException ex) {
                            Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                        }
                        textField_Vorname.updateUI();
                        textField_Nachname.updateUI();
                        textField_TelNr.updateUI();
                        textField_Raum.updateUI();
                        textField_Email.updateUI();

                                         
                        //textField_Vorname.revalidate();
                        //textField_Vorname.validate();
                    }
                });
                

                //Befüllen der ComboBox mit der HashMap (String, Person)

                JLabel label_PersonNachname = new JLabel("Nachname");
                label_PersonNachname.setBounds(50, 120, 90, 20);
                panel_PersonAendern.add(label_PersonNachname);

                textField_Nachname = new JTextField();
                textField_Nachname.setBounds(210, 120, 200, 20);
                panel_PersonAendern.add(textField_Nachname);

                JLabel label_PersonVorname = new JLabel("Vorname");
                label_PersonVorname.setBounds(50, 160, 90, 20);
                panel_PersonAendern.add(label_PersonVorname);

                textField_Vorname = new JTextField();
                textField_Vorname.setBounds(210, 160, 200, 20);
                panel_PersonAendern.add(textField_Vorname);

                JLabel label_Raum = new JLabel("Raum");
                label_Raum.setBounds(50, 200, 90, 20);
                panel_PersonAendern.add(label_Raum);

                textField_Raum = new JTextField();
                textField_Raum.setBounds(210, 200, 200, 20);
                panel_PersonAendern.add(textField_Raum);

                JLabel label_TelNr = new JLabel("Telefon");
                label_TelNr.setBounds(50, 240, 90, 20);
                panel_PersonAendern.add(label_TelNr);

                textField_TelNr = new JTextField();
                textField_TelNr.setBounds(210, 240, 200, 20);
                panel_PersonAendern.add(textField_TelNr);

                JLabel label_Email = new JLabel("Email");
                label_Email.setBounds(50, 280, 90, 20);
                panel_PersonAendern.add(label_Email);

                textField_Email = new JTextField();
                textField_Email.setBounds(210, 280, 200, 20);
                panel_PersonAendern.add(textField_Email);

                JButton button_Abbrechen = new JButton("Abbrechen");
                button_Abbrechen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                            zeichnePanelUebersicht();
                        }
                });
                button_Abbrechen.setBounds(210, 490, 120, 20);
                panel_PersonAendern.add(button_Abbrechen);



                button_Erstellen = new JButton("\u00C4ndern");
                button_Erstellen.addActionListener(new ActionListener() {
                      public void actionPerformed(ActionEvent arg0) {
                        // Es wird überprüft ob alle Felder ausgefüllt wurden, falls nicht, wird ein PopUp angezeigt und der Eintrag wird nicht an die Verwaltung übergeben
                        if (textField_Nachname.getText().equals("") || textField_Vorname.getText().equals("") || textField_TelNr.getText().equals("") || textField_Email.getText().equals("") || textField_Raum.getText().equals("")) {
                            JOptionPane.showMessageDialog(panel_PersonErstellen, "Bitte alle Felder ausfüllen!");   }

                         else {
                            
                                int fehler = 0;
                                // In das Person Objekt die neuen Daten befüllen
                                try {
                                    Integer.parseInt(textField_Raum.getText());
                                    Integer.parseInt(textField_TelNr.getText());
                                } catch (NumberFormatException numberFormatException) {
                                    JOptionPane.showMessageDialog(panel_PersonAendern, "In Raum & Telefon sind nur numerische Zeichen erlaubt.");
                                    // Wenn die Felder Raum und TelNr nicht geparst werden können da kein Integer integer eingegeben wurde, wird fehler auf 1 gesetzt
                                    fehler = 1;
                                }

                                // Wenn keine Fehler auftreten, wird die Person mit den neuen Daten befüllt und an die Verwaltung übergeben
                                if(fehler==0)
                                {
                                  try {
                                Person p = person.get(comboBox_PersonenWahl.getSelectedItem());
                                p.set_vorname(textField_Vorname.getText());
                                p.set_nachname(textField_Nachname.getText());
                                p.set_email(textField_Email.getText());
                                p.set_telefon(Integer.parseInt(textField_TelNr.getText()));
                                p.set_raum(Integer.parseInt(textField_Raum.getText()));
                                // Das editierte Objekt wird jetzt an die Verwaltung via updatePerson zurückgegeben
                                v.updatePerson(p);
                                JOptionPane.showMessageDialog(panel_PersonAendern, "Person wurde editiert.");

                                //Panel wurd neu gezeichnet um wieder die aktuellen Daten in der ComboBox zu laden
                                zeichnePanelUebersicht();
                                }

                             catch (RemoteException ex) {
                                Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                            }

                                }

                        }
                    }
                        
                });
                button_Erstellen.setBounds(50, 490, 90, 20);
                panel_PersonAendern.add(button_Erstellen);

                panel_PersonAendern.setVisible(true);

                // Auslesen des ersten Eintrages für die JTextFielder 
                 try {
                Integer t = person.get(comboBox_PersonenWahl.getSelectedItem()).get_telefon();
                Integer r = person.get(comboBox_PersonenWahl.getSelectedItem()).get_raum();
                textField_Vorname.setText(person.get(comboBox_PersonenWahl.getSelectedItem()).get_vorname());
                textField_Nachname.setText(person.get(comboBox_PersonenWahl.getSelectedItem()).get_nachname());
                textField_TelNr.setText(t.toString());
                textField_Raum.setText(r.toString());
                textField_Email.setText(person.get(comboBox_PersonenWahl.getSelectedItem()).get_email());
                    } catch (RemoteException ex) {
                        Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                    }
                    textField_Vorname.updateUI();
                    textField_Nachname.updateUI();
                    textField_TelNr.updateUI();
                    textField_Raum.updateUI();
                    textField_Email.updateUI();

        }

        private void zeichnePanelPersonLoeschen() {
                    versteckePanels();
                    Vector<Person> unsere_personen = new Vector();


                    // Wir lesen alle Personen aus und schreiben diese in einen neuen Vektor
                    try {
                        // Wir lesen alle Personen aus
                        v = getVerwaltung();
                        unsere_personen = v.getAllPerson();

                    } catch (RemoteException re) {
                    }

                    //Hashmap für die ComboBox wird erstellt
                    person = new HashMap<String, Person>();
                    for (int i = 0; i < unsere_personen.size(); i++) {
                        try {
                            person.put(unsere_personen.elementAt(i).get_voller_name(), unsere_personen.elementAt(i));
                        } catch (RemoteException ex) {
                        }
                    }

                    panel_Hintergrund.removeAll();

                    panel_PersonLoeschen = new JPanel();
                    panel_Hintergrund.add(panel_PersonLoeschen, BorderLayout.CENTER);
                    panel_PersonLoeschen.setLayout(null);

                    JLabel label_PersonLoeschen = new JLabel("Person l\u00F6schen");
                    label_PersonLoeschen.setFont(new Font("Tahoma", Font.PLAIN, 15));
                    label_PersonLoeschen.setBounds(50, 30, 220, 30);
                    panel_PersonLoeschen.add(label_PersonLoeschen);

                    JLabel label_PersonWaehlen = new JLabel("Person w\u00E4hlen");
                    label_PersonWaehlen.setBounds(50, 160, 130, 20);
                    panel_PersonLoeschen.add(label_PersonWaehlen);

                    comboBox_PersonenWahl = new JComboBox(new DefaultComboBoxModel());
                    comboBox_PersonenWahl.setBounds(210, 160, 200, 20);
                    panel_PersonLoeschen.add(comboBox_PersonenWahl);

                    for (String key : person.keySet()) {
                        comboBox_PersonenWahl.addItem(key);
                    }

                    button_Abbrechen = new JButton("Abbrechen");
                    button_Abbrechen.addActionListener(new ActionListener() {

                        public void actionPerformed(ActionEvent e) {
                        }
                    });
                    button_Abbrechen.setBounds(210, 490, 120, 20);
                    panel_PersonLoeschen.add(button_Abbrechen);

                    button_Erstellen = new JButton("L\u00F6schen");
                    button_Erstellen.addActionListener(new ActionListener() {

                        public void actionPerformed(ActionEvent arg0) {

                            Integer id_person_loeschen = null;
                            Integer id_person_eingeloggt = null;

                            // Es werden die Person IDs ausgelesen zum späteren Vergleich
                            try {
                                id_person_loeschen = person.get(comboBox_PersonenWahl.getSelectedItem()).get_person_id();
                                id_person_eingeloggt = eingeloggte_person.get_person_id();
                            } catch (RemoteException ex) {
                                Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                            }
                            if (id_person_loeschen != id_person_eingeloggt) {
                                // Wird ausgeführt wenn die Person die gelöscht werden soll ungleich der Person ist, die eingeloggt ist
                                int fehler = 3;
                                // Abfrage ob der Nutzer wirklich löschen möchte
                                int eingabe = JOptionPane.showConfirmDialog(null,
                                        "Möchten Sie die Person wirklich löschen?",
                                        "Löschen Bestätigung",
                                        JOptionPane.YES_NO_OPTION);
                                if (eingabe == 0) {

                                    // Person wird an Verwaltung übergeben und es wird versucht diese zu löschen. Bei einem Fehler wird eine RE
                                    try {
                                        v.deletePerson(person.get(comboBox_PersonenWahl.getSelectedItem()), eingeloggte_person);
                                        fehler = 0;
                                    } catch (RemoteException ex) {
                                        JOptionPane.showMessageDialog(panel_PersonLoeschen, "Es existieren noch Kalender oder Kategorien. Bitte überprüfen.");
                                        fehler = 1;
                                    }
                                }

                                if (fehler == 0) {
                                    JOptionPane.showMessageDialog(panel_PersonLoeschen, "Person erfolgreich gelöscht");
                                    zeichnePanelUebersicht();
                                }
                            }
                            else
                            {
                                // Wird ausgeführt wenn die Person die gelöscht werden soll ungleich der Person ist, die eingeloggt ist
                                int fehler = 3;
                                // Abfrage ob der Nutzer wirklich löschen möchte
                                int eingabe = JOptionPane.showConfirmDialog(null,
                                        "Wenn Sie sich selbst löschen, wird das Programm beendet. Sind Sie sicher das Sie sich selbst löschen wollen?",
                                        "Löschen Bestätigung",
                                        JOptionPane.YES_NO_OPTION);
                                if (eingabe == 0) {

                                    // Person wird an Verwaltung übergeben und es wird versucht diese zu löschen. Bei einem Fehler wird eine RE
                                    try {
                                        v.deletePerson(person.get(comboBox_PersonenWahl.getSelectedItem()), eingeloggte_person);
                                        fehler = 0;
                                    } catch (RemoteException ex) {
                                        JOptionPane.showMessageDialog(panel_PersonLoeschen, "Es existieren noch Kalender oder Kategorien. Bitte überprüfen.");
                                        fehler = 1;
                                    }
                                }

                                if (fehler == 0) {
                                    JOptionPane.showMessageDialog(panel_PersonLoeschen, "Person erfolgreich gelöscht");
                                    System.exit(0);
                                    
                                }
                            }
                        }
                    });
                    button_Erstellen.setBounds(50, 490, 90, 20);
                    panel_PersonLoeschen.add(button_Erstellen);

                    panel_PersonLoeschen.setVisible(true);
                }

        private void zeichnePanelKategorieAnlegen()
        {
                versteckePanels();

                panel_Hintergrund.removeAll();
                panel_KategorieAnlegen = new JPanel();
                panel_Hintergrund.add(panel_KategorieAnlegen, BorderLayout.CENTER);
                panel_KategorieAnlegen.setLayout(null);

                label_KategorieErstellen = new JLabel("Kategorie erstellen");
                label_KategorieErstellen.setFont(new Font("Tahoma", Font.PLAIN, 15));
                label_KategorieErstellen.setBounds(50, 30, 220, 30);
                panel_KategorieAnlegen.add(label_KategorieErstellen);

                label_KategorieName = new JLabel("Bezeichnung");
                label_KategorieName.setBounds(50, 80, 90, 20);
                panel_KategorieAnlegen.add(label_KategorieName);


                textField_Kategoriename = new JTextField();
                textField_Kategoriename.setBounds(210, 80, 150, 20);
                panel_KategorieAnlegen.add(textField_Kategoriename);



                button_Abbrechen = new JButton("Abbrechen");
                button_Abbrechen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                        }
                });
                button_Abbrechen.setBounds(210, 490, 120, 20);
                panel_KategorieAnlegen.add(button_Abbrechen);

                button_Erstellen = new JButton("Erstellen");
                button_Erstellen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent arg0) {
                                //Informationen aus Textfeldern ermitteln und in Datenstruktur schreiben
                                 if(textField_Kategoriename.getText().equals(""))
                                 JOptionPane.showMessageDialog(panel_PersonErstellen, "Bitte Bezeichnung ausfüllen!");
                                 else {
                                    try {
                                        v = getVerwaltung();
                                        v.createKategorie(1, textField_Kategoriename.getText(), eingeloggte_person.get_person_id());
                                        JOptionPane.showMessageDialog(panel_PersonErstellen, "Kategorie angelegt.");
                                        zeichnePanelUebersicht();
                                    } catch (RemoteException ex) {
                                        Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                    }
                                 }
                        }
                });
                button_Erstellen.setBounds(50, 490, 90, 20);
                panel_KategorieAnlegen.add(button_Erstellen);


                panel_KategorieAnlegen.setVisible(true);
        }

        private void zeichnePanelKategorieBearbeiten()
        {
                versteckePanels();

                Vector <Kategorie> unsere_kategorien = new Vector();


                // Wir lesen alle Personen aus und schreiben diese in einen neuen Vektor
                 try {
                     // Wir lesen alle Personen aus
                     v = getVerwaltung();
                     unsere_kategorien = v.getallKategorie_byPerson(eingeloggte_person.get_person_id());

                 } catch (RemoteException re) {

                 }

                //Hashmap für die ComboBox wird erstellt
                kategorie = new HashMap<String, Kategorie>();
                for (int i = 0; i < unsere_kategorien.size(); i++) {
                    try {
                        kategorie.put(unsere_kategorien.elementAt(i).get_name(), unsere_kategorien.elementAt(i));
                    } catch (RemoteException ex) {
                    }
                }

                panel_Hintergrund.removeAll();
                panel_KategorieAendern = new JPanel();
                panel_Hintergrund.add(panel_KategorieAendern, BorderLayout.CENTER);
                panel_KategorieAendern.setLayout(null);

                label_KategorieBearbeiten = new JLabel("Kategorie bearbeiten");
                label_KategorieBearbeiten.setFont(new Font("Tahoma", Font.PLAIN, 15));
                label_KategorieBearbeiten.setBounds(50, 30, 220, 30);
                panel_KategorieAendern.add(label_KategorieBearbeiten);

                label_Kategorie = new JLabel("Kategorie");
                label_Kategorie.setBounds(50, 120, 90, 20);
                panel_KategorieAendern.add(label_Kategorie);


                comboBox_Kategoriewahl = new JComboBox();
                comboBox_Kategoriewahl.setBounds(210, 120, 150, 20);
                panel_KategorieAendern.add(comboBox_Kategoriewahl);

                for (String key : kategorie.keySet()) {
                    comboBox_Kategoriewahl.addItem(key);
                }
                
                comboBox_Kategoriewahl.addActionListener(new ActionListener() {
                    public void actionPerformed(ActionEvent e) {
                        // Auslesen des ersten Eintrages für die JTextFielder
                    try {
                        textField_Kategoriename.setText(kategorie.get(comboBox_Kategoriewahl.getSelectedItem()).get_name());

                    } catch (RemoteException ex) {
                        Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                    }
                    textField_Kategoriename.updateUI();
                }
                });



                label_BezeichnungNeu = new JLabel("neuer Name");
                label_BezeichnungNeu.setBounds(50, 160, 90, 20);
                panel_KategorieAendern.add(label_BezeichnungNeu);

                textField_Kategoriename = new JTextField();
                textField_Kategoriename.setBounds(210, 160, 250, 20);
                panel_KategorieAendern.add(textField_Kategoriename);


                button_Abbrechen = new JButton("Abbrechen");
                button_Abbrechen.addActionListener(new ActionListener() {
                     public void actionPerformed(ActionEvent e) {
                    zeichnePanelUebersicht();
                }
            });
                button_Abbrechen.setBounds(210, 490, 120, 20);
                panel_KategorieAendern.add(button_Abbrechen);

                button_Erstellen = new JButton("\u00C4ndern");
                button_Erstellen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent arg0) {
                        // Es wird überprüft ob alle Felder ausgefüllt wurden, falls nicht, wird ein PopUp angezeigt und der Eintrag wird nicht an die Verwaltung übergeben
                        if (textField_Kategoriename.getText().equals("")) {
                            JOptionPane.showMessageDialog(panel_PersonErstellen, "Bitte eine Bezeichnung eingeben!");   }

                         else {
                                // Wenn keine Fehler auftreten, wird die Person mit den neuen Daten befüllt und an die Verwaltung übergeben
                                  try {
                                Kategorie k = kategorie.get(comboBox_Kategoriewahl.getSelectedItem());
                                k.set_name(textField_Kategoriename.getText());

                                // Das editierte Objekt wird jetzt an die Verwaltung via updateKategorie zurückgegeben
                                v.updateKategorie(k);
                                JOptionPane.showMessageDialog(panel_PersonAendern, "Kategorie wurde editiert.");

                                //Panel wurd neu gezeichnet um wieder die aktuellen Daten in der ComboBox zu laden
                                zeichnePanelUebersicht();
                                }

                             catch (RemoteException ex) {
                                Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                            }

                               

                        }
                    }
                });
                button_Erstellen.setBounds(50, 490, 90, 20);
                panel_KategorieAendern.add(button_Erstellen);

                panel_KategorieAendern.setVisible(true);

                // Auslesen des ersten Eintrages für die JTextFielder
                 try {
                textField_Kategoriename.setText(kategorie.get(comboBox_Kategoriewahl.getSelectedItem()).get_name());

                    } catch (RemoteException ex) {
                        Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                    }
                    textField_Kategoriename.updateUI();

        }

        private void zeichnePanelKategorieLoeschen()
        {
                versteckePanels();

                Vector <Kategorie> unsere_kategorien = new Vector();


                // Wir lesen alle Personen aus und schreiben diese in einen neuen Vektor
                 try {
                     // Wir lesen alle Personen aus
                     v = getVerwaltung();
                     unsere_kategorien = v.getallKategorie_byPerson(eingeloggte_person.get_person_id());

                 } catch (RemoteException re) {

                 }

                //Hashmap für die ComboBox wird erstellt
                kategorie = new HashMap<String, Kategorie>();
                for (int i = 0; i < unsere_kategorien.size(); i++) {
                    try {
                        kategorie.put(unsere_kategorien.elementAt(i).get_name(), unsere_kategorien.elementAt(i));
                    } catch (RemoteException ex) {
                    }
                }

                panel_KategorieLoeschen = new JPanel();
                panel_Hintergrund.add(panel_KategorieLoeschen, BorderLayout.CENTER);
                panel_KategorieLoeschen.setLayout(null);

                label_KategorieBearbeiten = new JLabel("Kategorie l\u00F6schen");
                label_KategorieBearbeiten.setFont(new Font("Tahoma", Font.PLAIN, 15));
                label_KategorieBearbeiten.setBounds(50, 30, 220, 30);
                panel_KategorieLoeschen.add(label_KategorieBearbeiten);

                label_Kategorie = new JLabel("Kategorie w\u00E4hlen");
                label_Kategorie.setBounds(50, 120, 130, 20);
                panel_KategorieLoeschen.add(label_Kategorie);

                comboBox_Kategoriewahl = new JComboBox();
                comboBox_Kategoriewahl.setBounds(210, 120, 150, 20);
                panel_KategorieLoeschen.add(comboBox_Kategoriewahl);

                for (String key : kategorie.keySet()) {
                    comboBox_Kategoriewahl.addItem(key);
                }

                button_Abbrechen = new JButton("Abbrechen");
                button_Abbrechen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                        }
                });
                button_Abbrechen.setBounds(210, 490, 120, 20);
                panel_KategorieLoeschen.add(button_Abbrechen);

                button_Loeschen = new JButton("L\u00F6schen");
                button_Loeschen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent arg0) {

                                int fehler = 3;
                                // Abfrage ob der Nutzer wirklich löschen möchte
                                int eingabe = JOptionPane.showConfirmDialog(null,
                                        "Möchten Sie die Kategorie wirklich löschen?",
                                        "Löschen Bestätigung",
                                        JOptionPane.YES_NO_OPTION);
                                if (eingabe == 0) {

                                    // Person wird an Verwaltung übergeben und es wird versucht diese zu löschen. Bei einem Fehler wird eine RE
                                    try {
                                        v.deleteKategorie(kategorie.get(comboBox_Kategoriewahl.getSelectedItem()));
                                        fehler = 0;
                                    } catch (RemoteException ex) {
                                        JOptionPane.showMessageDialog(panel_PersonLoeschen, "Die Kategorie ist noch mit Kalendereinträgen verknüpft. Bitte überprüfen.");
                                        fehler = 1;
                                    }
                                }

                                if (fehler == 0) {
                                    JOptionPane.showMessageDialog(panel_PersonLoeschen, "Kategorie erfolgreich gelöscht");
                                    zeichnePanelUebersicht();
                                }


                        }
                });
                button_Loeschen.setBounds(50, 490, 90, 20);
                panel_KategorieLoeschen.add(button_Loeschen);
                panel_KategorieLoeschen.setVisible(true);
        }

        private void zeichnePanelAlarmAnlegen()
        {
                versteckePanels();

                panel_Hintergrund.removeAll();
                panel_alarm_anlegen = new JPanel();
                panel_Hintergrund.add(panel_alarm_anlegen, BorderLayout.CENTER);
                panel_alarm_anlegen.setLayout(null);

                label_alarm_anlegen = new JLabel("Alarm erstellen");
                label_alarm_anlegen.setFont(new Font("Tahoma", Font.PLAIN, 15));
                label_alarm_anlegen.setBounds(50, 30, 220, 30);
                panel_alarm_anlegen.add(label_alarm_anlegen);

                label_alarm_bezeichnung = new JLabel("Bezeichnung");
                label_alarm_bezeichnung.setBounds(50, 80, 220, 30);
                panel_alarm_anlegen.add(label_alarm_bezeichnung);

                textField_alarm_bezeichnung = new JTextField();
                textField_alarm_bezeichnung.setBounds(210, 80, 150, 20);
                panel_alarm_anlegen.add(textField_alarm_bezeichnung);

                label_alarm_uhrzeit = new JLabel("Bezeichnung");
                label_alarm_uhrzeit.setBounds(50, 135, 220, 30);
                panel_alarm_anlegen.add(label_alarm_uhrzeit);

                textField_startdatum = new JTextField();
                textField_startdatum.enableInputMethods(true);
                textField_startdatum.setEditable(false);
                textField_startdatum.setBounds(210, 140, 80, 20);
                panel_alarm_anlegen.add(textField_startdatum);

                final JFrame f = new JFrame();

                f.setTitle("Startdatum auswählen");

                f.pack();
                f.setVisible(false);

                button_startdatum = new JButton("Kalender öffnen");
                button_startdatum.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                            textField_startdatum.setText(new DatePicker(f).setPickedDate());
                        }
                });
                button_startdatum.setBounds(300, 140, 130, 20);
                panel_alarm_anlegen.add(button_startdatum);

                JLabel label_startuhrzeit = new JLabel("Startzeit wählen:");
                label_startuhrzeit.setBounds(450, 135, 170, 30);
                panel_alarm_anlegen.add(label_startuhrzeit);



                comboBox_Tag = new JComboBox();
                comboBox_Tag.setBounds(560, 140, 50, 20);
                panel_alarm_anlegen.add(comboBox_Tag);
                for(int i=0; i<24; i++)
                {
                    // Für 2 stellige Ausgabe in der ComboBox, wichtig auch zum parsen des Datums z.B. 1 -> 01
                    String zahl = String.format("%02d", i);
                    comboBox_Tag.addItem(zahl);
                }


                comboBox_Monat = new JComboBox();
                comboBox_Monat.setBounds(620, 140, 50, 20);
                panel_alarm_anlegen.add(comboBox_Monat);

                for(int i=0; i<60; i++)
                {
                     // Für 2 stellige Ausgabe in der ComboBox, wichtig auch zum parsen des Datums z.B. 1 -> 01
                    String zahl = String.format("%02d", i);
                    comboBox_Monat.addItem(zahl);
                }

                button_Abbrechen = new JButton("Abbrechen");
                button_Abbrechen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {

                        }
                });
                button_Abbrechen.setBounds(210, 490, 120, 20);
                panel_alarm_anlegen.add(button_Abbrechen);

                button_Erstellen = new JButton("Anlegen");
                button_Erstellen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent arg0) {
                                //Informationen aus Textfeldern ermitteln und in Datenstruktur schreiben
                                 if(textField_alarm_bezeichnung.getText().equals("") || textField_startdatum.getText().equals("") )
                                 JOptionPane.showMessageDialog(panel_alarm_anlegen, "Bitte alle Felder ausfüllen!");
                                 else {
                                            try {

                                        // 1. StartDatum auslesen, parsen und als Timestamp abspeichern

                                        // String mit allen Angaben des Startdatums bauen
                                        String volles_Datum_start = textField_startdatum.getText() + " " + comboBox_Tag.getSelectedItem() + ":" + comboBox_Monat.getSelectedItem();

                                       // String wird via SimpleDateFormat geparst, da es zu Fehlern kommen kann mit try/catch Block abgefangen
                                       SimpleDateFormat start_date = new SimpleDateFormat("dd-MM-yyyy HH:mm");

                                            try {
                                                start_date_1 = start_date.parse(volles_Datum_start);
                                            } catch (ParseException ex) {
                                                Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                            }

                                       // SimpleDateFormat wird in GregorianCalendar konvertiert und daraus dann ein Timestamp erzeugt

                                            Calendar cal_start = Calendar.getInstance();
                                            cal_start.setTime(start_date_1);                    // Startzeitpunkt
                                            cal_start.set(Calendar.MILLISECOND, 0);
                                            Timestamp sta = new Timestamp(cal_start.getTimeInMillis());


                                        // Erstellen unseres Alarm Objektes
                                        Alarm x = new AlarmImpl();
                                        x.set_alarm_id(0); // Wird von der DB ersetzt
                                        x.set_bezeichnung(textField_alarm_bezeichnung.getText());
                                        x.set_person_id(eingeloggte_person.get_person_id());
                                        x.set_zeitpunkt(sta);

                                        v = getVerwaltung();
                                        v.createAlarm(x);
                                        JOptionPane.showMessageDialog(panel_PersonErstellen, "Alarm angelegt.");
                                        zeichnePanelUebersicht();
                                    } catch (RemoteException ex) {
                                        Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                    }
                                 }
                        }
                });
                button_Erstellen.setBounds(50, 490, 90, 20);
                panel_alarm_anlegen.add(button_Erstellen);


                panel_alarm_anlegen.setVisible(true);
        }

        private void zeichne_alarm_editieren()
        {
                versteckePanels();

                Vector <Alarm> unsere_alarme = new Vector();

                try {
                     // Wir lesen alle Alarme der eingeloggten Person aus
                     v = getVerwaltung();
                     unsere_alarme = v.findall_alarm_by_person(eingeloggte_person.get_person_id());

                 } catch (RemoteException re) {

                 }

                //Hashmap für die ComboBox wird erstellt
                alarm = new HashMap<String, Alarm>();
                for (int i = 0; i < unsere_alarme.size(); i++) {
                    try {
                        alarm.put(unsere_alarme.elementAt(i).get_bezeichnung(), unsere_alarme.elementAt(i));
                    } catch (RemoteException ex) {
                    }
                }

                panel_Hintergrund.removeAll();
                panel_alarm_editieren = new JPanel();
                panel_Hintergrund.add(panel_alarm_editieren, BorderLayout.CENTER);
                panel_alarm_editieren.setLayout(null);

                label_alarm_editieren = new JLabel("Alarm editieren");
                label_alarm_editieren.setFont(new Font("Tahoma", Font.PLAIN, 15));
                label_alarm_editieren.setBounds(50, 30, 220, 30);
                panel_alarm_editieren.add(label_alarm_editieren);

                label_comboBox_alarm = new JLabel("Alarm wählen");
                label_comboBox_alarm.setBounds(50, 80, 220, 30);
                panel_alarm_editieren.add(label_comboBox_alarm);

                comboBox_alarm_bezeichnung = new JComboBox();
                comboBox_alarm_bezeichnung.setBounds(210, 85, 220, 20);
                panel_alarm_editieren.add(comboBox_alarm_bezeichnung);

                for (String key : alarm.keySet()) {
                    comboBox_alarm_bezeichnung.addItem(key);
                }

                comboBox_alarm_bezeichnung.addActionListener(new ActionListener() {
                    public void actionPerformed(ActionEvent e) {
                        // Auslesen der Eintrags für die JTextFielder und Datum
                    try {
                        textField_alarm_editieren.setText(alarm.get(comboBox_alarm_bezeichnung.getSelectedItem()).get_bezeichnung());

                        //Setzen des Datums
                        String s = new SimpleDateFormat("dd-MM-yyyy").format(alarm.get(comboBox_alarm_bezeichnung.getSelectedItem()).get_zeitpunkt());
                        textField_startdatum.setText(s);
                        //Setzen der Uhrzeit
                        s = new SimpleDateFormat("HH").format(alarm.get(comboBox_alarm_bezeichnung.getSelectedItem()).get_zeitpunkt());
                        comboBox_Tag.setSelectedItem(s);
                        s = new SimpleDateFormat("mm").format(alarm.get(comboBox_alarm_bezeichnung.getSelectedItem()).get_zeitpunkt());
                        comboBox_Monat.setSelectedItem(s);



                    } catch (RemoteException ex) {
                        Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                    }
                    textField_alarm_editieren.updateUI();
                }
                });

                label_alarm_bezeichnung = new JLabel("Bezeichnung");
                label_alarm_bezeichnung.setBounds(50, 140, 220, 30);
                panel_alarm_editieren.add(label_alarm_bezeichnung);

                textField_alarm_editieren = new JTextField();
                textField_alarm_editieren.setBounds(210, 140, 150, 20);
                panel_alarm_editieren.add(textField_alarm_editieren);

                label_alarm_uhrzeit = new JLabel("Datum wählen");
                label_alarm_uhrzeit.setBounds(50, 165, 220, 30);
                panel_alarm_editieren.add(label_alarm_uhrzeit);

                textField_startdatum = new JTextField();
                textField_startdatum.enableInputMethods(true);
                textField_startdatum.setEditable(false);
                textField_startdatum.setBounds(210, 170, 80, 20);
                panel_alarm_editieren.add(textField_startdatum);

                final JFrame f = new JFrame();

                f.setTitle("Startdatum auswählen");

                f.pack();
                f.setVisible(false);

                button_startdatum = new JButton("Kalender öffnen");
                button_startdatum.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                            textField_startdatum.setText(new DatePicker(f).setPickedDate());
                        }
                });
                button_startdatum.setBounds(300, 170, 130, 20);
                panel_alarm_editieren.add(button_startdatum);

                JLabel label_startuhrzeit = new JLabel("Startzeit wählen:");
                label_startuhrzeit.setBounds(450, 165, 170, 30);
                panel_alarm_editieren.add(label_startuhrzeit);



                comboBox_Tag = new JComboBox();
                comboBox_Tag.setBounds(560, 170, 50, 20);
                panel_alarm_editieren.add(comboBox_Tag);
                for(int i=0; i<24; i++)
                {
                    // Für 2 stellige Ausgabe in der ComboBox, wichtig auch zum parsen des Datums z.B. 1 -> 01
                    String zahl = String.format("%02d", i);
                    comboBox_Tag.addItem(zahl);
                }


                comboBox_Monat = new JComboBox();
                comboBox_Monat.setBounds(620, 170, 50, 20);
                panel_alarm_editieren.add(comboBox_Monat);

                for(int i=0; i<60; i++)
                {
                     // Für 2 stellige Ausgabe in der ComboBox, wichtig auch zum parsen des Datums z.B. 1 -> 01
                    String zahl = String.format("%02d", i);
                    comboBox_Monat.addItem(zahl);
                }

                button_Abbrechen = new JButton("Abbrechen");
                button_Abbrechen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                            zeichnePanelUebersicht();
                        }
                });
                button_Abbrechen.setBounds(210, 490, 120, 20);
                panel_alarm_editieren.add(button_Abbrechen);

                button_Erstellen = new JButton("Editieren");
                button_Erstellen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent arg0) {
                                //Informationen aus Textfeldern ermitteln und in Datenstruktur schreiben
                                 if(textField_alarm_editieren.getText().equals("") || textField_startdatum.getText().equals("") )
                                 JOptionPane.showMessageDialog(panel_alarm_editieren, "Bitte alle Felder ausfüllen!");
                                 else {
                                            try {

                                        // 1. StartDatum auslesen, parsen und als Timestamp abspeichern

                                        // String mit allen Angaben des Startdatums bauen
                                        String volles_Datum_start = textField_startdatum.getText() + " " + comboBox_Tag.getSelectedItem() + ":" + comboBox_Monat.getSelectedItem();

                                       // String wird via SimpleDateFormat geparst, da es zu Fehlern kommen kann mit try/catch Block abgefangen
                                       SimpleDateFormat start_date = new SimpleDateFormat("dd-MM-yyyy HH:mm");

                                            try {
                                                start_date_1 = start_date.parse(volles_Datum_start);
                                            } catch (ParseException ex) {
                                                Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                            }

                                       // SimpleDateFormat wird in GregorianCalendar konvertiert und daraus dann ein Timestamp erzeugt

                                            Calendar cal_start = Calendar.getInstance();
                                            cal_start.setTime(start_date_1);                    // Startzeitpunkt
                                            cal_start.set(Calendar.MILLISECOND, 0);
                                            Timestamp sta = new Timestamp(cal_start.getTimeInMillis());


                                        // Ändern unseres Alarm Objektes
                                        alarm.get(comboBox_alarm_bezeichnung.getSelectedItem()).set_bezeichnung(textField_alarm_editieren.getText());
                                        alarm.get(comboBox_alarm_bezeichnung.getSelectedItem()).set_zeitpunkt(sta);

                                        v = getVerwaltung();
                                        v.updateAlarm(alarm.get(comboBox_alarm_bezeichnung.getSelectedItem()));
                                        JOptionPane.showMessageDialog(panel_PersonErstellen, "Alarm editiert.");
                                        zeichnePanelUebersicht();
                                    } catch (RemoteException ex) {
                                        Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                    }
                                 }
                        }
                });
                button_Erstellen.setBounds(50, 490, 90, 20);
                panel_alarm_editieren.add(button_Erstellen);

                // Auslesen des ersten Eintrages für die JTextFielder
                    try {
                        textField_alarm_editieren.setText(alarm.get(comboBox_alarm_bezeichnung.getSelectedItem()).get_bezeichnung());
                         //Setzen des Datums für das einmalige Lesen am start
                        String s = new SimpleDateFormat("dd-MM-yyyy").format(alarm.get(comboBox_alarm_bezeichnung.getSelectedItem()).get_zeitpunkt());
                        textField_startdatum.setText(s);
                        //Setzen der Uhrzeit
                        s = new SimpleDateFormat("HH").format(alarm.get(comboBox_alarm_bezeichnung.getSelectedItem()).get_zeitpunkt());
                        comboBox_Tag.setSelectedItem(s);
                        s = new SimpleDateFormat("mm").format(alarm.get(comboBox_alarm_bezeichnung.getSelectedItem()).get_zeitpunkt());
                        comboBox_Monat.setSelectedItem(s);
                    } catch (RemoteException ex) {
                        Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                    }
                    textField_alarm_editieren.updateUI();

                panel_alarm_editieren.setVisible(true);

        }

        private void zeichne_alarm_loeschen()
        {
                versteckePanels();

                Vector <Alarm> unsere_alarme = new Vector();

                try {
                     // Wir lesen alle Alarme der eingeloggten Person aus
                     v = getVerwaltung();
                     unsere_alarme = v.findall_alarm_by_person(eingeloggte_person.get_person_id());

                 } catch (RemoteException re) {

                 }

                //Hashmap für die ComboBox wird erstellt
                alarm = new HashMap<String, Alarm>();
                for (int i = 0; i < unsere_alarme.size(); i++) {
                    try {
                        alarm.put(unsere_alarme.elementAt(i).get_bezeichnung(), unsere_alarme.elementAt(i));
                    } catch (RemoteException ex) {
                    }
                }

                panel_Hintergrund.removeAll();
                panel_alarm_loeschen = new JPanel();
                panel_Hintergrund.add(panel_alarm_loeschen, BorderLayout.CENTER);
                panel_alarm_loeschen.setLayout(null);

                label_alarm_loeschen = new JLabel("Alarm löschen");
                label_alarm_loeschen.setFont(new Font("Tahoma", Font.PLAIN, 15));
                label_alarm_loeschen.setBounds(50, 30, 220, 30);
                panel_alarm_loeschen.add(label_alarm_loeschen);

                label_comboBox_alarm = new JLabel("Alarm wählen");
                label_comboBox_alarm.setBounds(50, 80, 220, 30);
                panel_alarm_loeschen.add(label_comboBox_alarm);

                comboBox_alarm_bezeichnung = new JComboBox();
                comboBox_alarm_bezeichnung.setBounds(210, 85, 250, 20);
                panel_alarm_loeschen.add(comboBox_alarm_bezeichnung);

                for (String key : alarm.keySet()) {
                    comboBox_alarm_bezeichnung.addItem(key);
                }


                button_Erstellen = new JButton("Löschen");
                button_Erstellen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent arg0) {

                                int fehler = 3;
                                // Abfrage ob der Nutzer wirklich löschen möchte
                                int eingabe = JOptionPane.showConfirmDialog(null,
                                        "Möchten Sie den Alarm wirklich löschen?",
                                        "Löschen Bestätigung",
                                        JOptionPane.YES_NO_OPTION);
                                if (eingabe == 0) {

                                    // Person wird an Verwaltung übergeben und es wird versucht diese zu löschen. Bei einem Fehler wird eine RE
                                    try {
                                        v.deleteAlarm(alarm.get(comboBox_alarm_bezeichnung.getSelectedItem()));
                                        fehler = 0;
                                    } catch (RemoteException ex) {

                                        fehler = 1;
                                    }
                                }

                                if (fehler == 0) {
                                    JOptionPane.showMessageDialog(panel_alarm_loeschen, "Alarm erfolgreich gelöscht.");
                                    zeichnePanelUebersicht();
                                }


                        }
                });
             
                button_Erstellen.setBounds(50, 490, 90, 20);
                panel_alarm_loeschen.add(button_Erstellen);

                button_Abbrechen = new JButton("Abbrechen");
                button_Abbrechen.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                            zeichnePanelUebersicht();
                        }
                });
                button_Abbrechen.setBounds(210, 490, 120, 20);
                panel_alarm_loeschen.add(button_Abbrechen);


        }

        private void zeichnePanelUebersicht()
        {
                versteckePanels();
                panel_Hintergrund.removeAll();
                panel_Uebersicht = new JPanel();
                panel_Hintergrund.add(panel_Uebersicht, BorderLayout.CENTER);
                panel_Uebersicht.setLayout(null);

                label_uebersichtErstellen = new JLabel("Übersicht");
                label_uebersichtErstellen.setFont(new Font("Tahoma", Font.PLAIN, 15));
                label_uebersichtErstellen.setBounds(50, 30, 220, 30);
                panel_Uebersicht.add(label_uebersichtErstellen);
                    try {
                        label_uebersicht = new JLabel("<html>Sie sind momentan eingeloggt als: <br><font size=+2>" + eingeloggte_person.get_voller_name() + "</font></html>");
                    } catch (RemoteException ex) {
                        Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                    }
                label_uebersicht.setBounds(50, 445, 500, 70);
                panel_Uebersicht.add(label_uebersicht);



                panel_Uebersicht.setVisible(true);
        }

        private void initPanels()
        {
                panel_KalenderAnlegen = new JPanel();
                panel_KalenderAendern = new JPanel();
                panel_KalenderLoeschen = new JPanel();
                panel_KalendereintragErstellen = new JPanel();
                panel_KalendereintragAendern = new JPanel();
                panel_KalendereintragLoeschen = new JPanel();
                panel_PersonErstellen = new JPanel();
                panel_PersonAendern = new JPanel();
                panel_PersonLoeschen = new JPanel();
                panel_KategorieAnlegen = new JPanel();
                panel_KategorieAendern = new JPanel();
                panel_KategorieLoeschen = new JPanel();
                panel_AlarmSetzen = new JPanel();
                panel_Uebersicht = new JPanel();
                panel_Einladung = new JPanel();
                panel_alarm_anlegen = new JPanel();
                panel_alarm_editieren = new JPanel();
                panel_alarm_loeschen = new JPanel();

        }

        // Zusatzmethode für Kalendereintrag editieren / Neuberechnung des Frames
        private void initKalendereintrag()
        {
            System.out.println("Checkbox Kalendereintrag wurde angeklickt");


    // Als erstes werden alle Einträge entfernt
            //comboBox_Eintrag.removeAllItems();
               // Als erstes werden alle Einträge entfernt
                

             comboBox_Eintrag.removeAllItems();
                  
                
            kalendereintrag = new HashMap<String, Kalendereintrag>();




    // Ausblendung der Elemente Wiederholen? Teilnehmer hinzufügen?
            chckbxWiederholen.setVisible(false);
            chckbxTermin.setVisible(false);

            for (int i = 0; i < unsere_kalendereintraege.size(); i++) {
                try {

                    kalendereintrag.put("<html><u>" + unsere_kalendereintraege.elementAt(i).get_beschreibung() + "</u><br>" + unsere_kalendereintraege.elementAt(i).get_ort() + "</html>", unsere_kalendereintraege.elementAt(i));

                } catch (RemoteException ex) {
                }
            }

         //ComboBox mit Einträgen der HashMap befüllen
            for (String key : kalendereintrag.keySet()) {
                comboBox_Eintrag.addItem(key);
            }
            comboBox_Eintrag.updateUI();
        }

                // Zusatzmethode für Kalendereintrag editieren / Neuberechnung des Frames
        private void initTermin()
        {
            System.out.println("Checkbox Termin wurde angeklickt");


            // Als erstes werden alle Einträge entfernt
            //comboBox_Eintrag.removeAllItems();
               // Als erstes werden alle Einträge entfernt


             comboBox_Eintrag.removeAllItems();


            termine = new HashMap<String, Termin>();




            // Ausblendung der Elemente Wiederholen? Teilnehmer hinzufügen?
            chckbxWiederholen.setVisible(false);
            chckbxTermin.setVisible(true);

            for (int i = 0; i < unsere_termine.size(); i++) {
                try {

                    termine.put("<html><u>" + unsere_termine.elementAt(i).get_beschreibung() + "</u><br>" + unsere_termine.elementAt(i).get_ort() + "</html>", unsere_termine.elementAt(i));

                } catch (RemoteException ex) {
                }
            }

         //ComboBox mit Einträgen der HashMap befüllen
            for (String key : termine.keySet()) {
                comboBox_Eintrag.addItem(key);
            }
            comboBox_Eintrag.updateUI();
        }

         // Zusatzmethode für Kalendereintrag editieren / Neuberechnung des Frames
        private void initWiederholungeintrag()
        {
            System.out.println("Checkbox Wiederholungseintrag wurde angeklickt");


            // Als erstes werden alle Einträge entfernt
                    //comboBox_Eintrag.removeAllItems();

            // Als erstes werden alle Einträge entfernt
               
                    
                    comboBox_Eintrag.removeAllItems();
                    

                
               

                    wiederholungen = new HashMap<String, Wiederholung>();




            // Ausblendung der Elemente Wiederholen? Teilnehmer hinzufügen?
                    chckbxWiederholen.setVisible(true);
                    chckbxTermin.setVisible(false);

                    for (int i = 0; i < unsere_wiederholungen.size(); i++) {
                        try {

                            wiederholungen.put("<html><u>" + unsere_wiederholungen.elementAt(i).get_beschreibung() + "</u><br>" + unsere_wiederholungen.elementAt(i).get_ort() + "</html>", unsere_wiederholungen.elementAt(i));

                        } catch (RemoteException ex) {
                        }
                    }

            //ComboBox mit Einträgen der HashMap befüllen
                    for (String key : wiederholungen.keySet()) {
                        comboBox_Eintrag.addItem(key);
                    }
                    comboBox_Eintrag.updateUI();
                }

        private void initTerminWiederholung()
        {
            System.out.println("Checkbox TerminWiederholung wurde angeklickt");


            // Als erstes werden alle Einträge entfernt
                    //comboBox_Eintrag.removeAllItems();

            // Als erstes werden alle Einträge entfernt


                    comboBox_Eintrag.removeAllItems();





                    termin_wiederholungen = new HashMap<String, Termin>();




            // Ausblendung der Elemente Wiederholen? Teilnehmer hinzufügen?
                    chckbxWiederholen.setVisible(true);
                    chckbxTermin.setVisible(true);

                    for (int i = 0; i < unsere_termin_wiederholung.size(); i++) {
                        try {

                            termin_wiederholungen.put("<html><u>" + unsere_termin_wiederholung.elementAt(i).get_beschreibung() + "</u><br>" + unsere_termin_wiederholung.elementAt(i).get_ort() + "</html>", unsere_termin_wiederholung.elementAt(i));

                        } catch (RemoteException ex) {
                        }
                    }

            //ComboBox mit Einträgen der HashMap befüllen
                    for (String key : termin_wiederholungen.keySet()) {
                        comboBox_Eintrag.addItem(key);
                    }
                    comboBox_Eintrag.updateUI();
                }
        }

